✔ Boost Regex.lib welche Parameter bei regex_match()?

O

Oklino

Mitglied
Hallo ich habe mir kürzlich und nach langem hin und her mit dem Builder von boost die regex library zu installieren (am ende doch via mak file)

Nun jetzt muss ich erst einmal zugeben, dass mein teschnisches (IT) Englisch mittelmäßig bis schlecht ist und ich in der Boost Dokumentation nicht weiter komme (ein Grund weshalb ich denke, dass Tutorials.de die richtige Anlaufstelle für Hilfe ist :) )

Ich habe ein Programm mit dem BCB6.0 geschrieben und führe dort mittels dieser Zeilen:

Code: 
strE = strListOrte->Strings[0].c_str();
            s = dinohsname.c_str();
            static const boost::regex e(strE);
            bMatch = regex_search(s, e);

einen vergleich durch. Ziel ist es dass hier ein Match bei z.B.

e = recklingh[a-z].*
und
s = rechlinghsn orthlostr

erzielt wird. Leider funktioniert das in dieser Version nicht. Im ersten Anlauf matchen Strings wie

abcd[a-z].* und abcd efg
kommt dann aber
abc[a-z].* und abcd efg - was kein match ergibt, dann match das Programm im weiteren verlauf selbst abcd[a-z].* und abcd efg nicht mehr... Man hat mir bis jetzt ohne weitere Hinweise angedeutet, dass ich noch einen Parameter/Argument einsetzen muss um festzulegen WIE gematch werden soll. Die Liste in der Doku verstehe ich allerdings nicht :/ kann mir bei der ganzen Sache hier jemand weiterhelfen?

Vielen Dank im Voraus
 
Zuletzt bearbeitet:
Oklino hat gesagt.:
Im ersten Anlauf matchen Strings wie

abcd[a-z].* und abcd efg
kommt dann aber
abc[a-z].* und abcd efg - was kein match ergibt, dann match das Programm im weiteren verlauf selbst abcd[a-z].* und abcd efg nicht mehr...
Zum Vergrößern anklicken....
"abcd efg" kann nicht vom reg. Ausdruck "abcd[a-z].*" akzeptiert werden - das Leerzeichen ist nicht Teil der Zeichenklasse [a-z]. Im zweiten Fall sollte allerdings sollte der Ausdruck mit dem Suchstring übereinstimmen.

Also bei mir funktioniert's auch ohne spezielle Flags:
Code: 
#include <iostream>
#include <string>
#include <boost/regex.hpp>

using namespace std;

int main() {
        boost::regex expr ("abcd[a-z].*");

        string line;
        while (getline(cin, line)) {
                if (boost::regex_search(line, expr)) {
                        cout << "line matches." << endl;
                } else {
                        cout << "line does *not* match." << endl;
                }
        }
}
Gruß
 
ups ich habe gerade gesehen, dass ich oben die Version mit regex_search() gepostet habe... ;) naja... aber damit sollte es dann funktionieren, wenn ich den regulären Ausdruck anpasse?

es sollte dann doch mit

exp = abc[a-z| |0-9]*
strE = abcd efg 123

klappen, oder?

achja nochwas... der RegexCoach meinte dass [a-z].* nen match macht, ich denke mal weil "." für "beliebiges Zeichen"(auch leerzeichen) steht und ".*" wäre dann ja "beliebiges zeichen, beliebig(es Zeichen beliebig) oft" oder so ähnlich.
 
Zuletzt bearbeitet:
Oklino hat gesagt.:
ups ich habe gerade gesehen, dass ich oben die Version mit regex_search() gepostet habe... ;) naja... aber damit sollte es dann funktionieren, wenn ich den regulären Ausdruck anpasse?
Zum Vergrößern anklicken....
Ja.

Oklino hat gesagt.:
es sollte dann doch mit

exp = abc[a-z| |0-9]*
strE = abcd efg 123

klappen, oder?
Zum Vergrößern anklicken....
Ja. (Der senkrechte Strich ist allerdings doppelt)

Oklino hat gesagt.:
achja nochwas... der RegexCoach meinte dass [a-z].* nen match macht, ich denke mal weil "." für "beliebiges Zeichen"(auch leerzeichen) steht und ".*" wäre dann ja "beliebiges zeichen, beliebig(es Zeichen beliebig) oft" oder so ähnlich.
Zum Vergrößern anklicken....
Ja.

Gruß
 
Oklino hat gesagt.:
OR bei reg. Audr. = || ?

[a-z|| ||0-9]*

?
Zum Vergrößern anklicken....
:confused: Vielleicht hättest du mal sagen sollen was du mit dem Ausdruck meinst.

Die eckigen Klammern sind eine Zeichenklasse, d.h. an Stelle dieser Klasse kann ein Zeichen von innerhalb der Klammern stehen. Spezialzeichen verlieren innerhalb einer Zeichenklasse ihre Bedeutung. D.h. ein | ist ein ganz normales Zeichen - und wenn du es 10-mal innerhalb der Klammern schreibst, wird es doch nur max. 1-mal mit einem Zeichen im Suchstring übereinstimmen.

Was dein Ausdruck bedeutet ist folgendes: Zuerst muß ein Zeichen aus dem Bereich a bis z oder ein | Zeichen oder ein | Zeichen oder ein Leerzeichen oder ein | Zeichen oder ein | Zeichen oder ein Zeichen im Bereich 0 bis 9 sein. Das dann beliebig oft (auch überhaupt nicht!).

Ich nehme mal an du willst Buchstaben, Leerzeichen und Ziffern akzeptieren: [a-z 0-9]*

Gruß
 
ja genau :) danke.

ich hab das soweit korrigiert, aber beim debuggen matcht er

recklingh[a-z 0-9]*
immernoch nicht mit
recklinhsn orthlostr nr 190

vielleicht mache ich ja was anderes falsch. ich poste mal nen paar Zeilen, die vielleicht wichtig/fehlerhaft sein könnten...

bau des pattern:
Code: 
case 5:
                      strE = strListOrte->Strings[0].c_str();

                      if(strListOrte->Count == 1)
                      strE += "[a-z 0-9]*";
                      else
                      strE += "[a-z 0-9]* ";

                          for(i = 1; i < (strListOrte->Count); i++)
                          {
                          strE += strListOrte->Strings[i].c_str();
                          strE += "[a-z 0-9]* ";

                          if(i == (strListOrte->Count-1))
                          strE += "[a-z 0-9]*";
                          }

                      break;
                      default:
                      bMatch = false;
                      }//endofswitch

dann das Matchen...

Code: 
static const boost::regex e(strE);
bMatch = boost::regex_match(s, e); 
           if(bMatch == 0)

zwischendruch wird der Ort noch von mir gekürzt:

Code: 
nVarCounter = strListOrte->Strings[0].Length(); // wie lang ist der Ortname?
if(nVarCounter > 1)
{
strListOrte->Strings[0] = strListOrte->Strings[0].SetLength((nVarCounter-1));
nVarCounter2 = strListOrte->Count;

(...)
danach wird dann wieder das obige Konstrukt wiederholt
 
Oklino hat gesagt.:
ich hab das soweit korrigiert, aber beim debuggen matcht er

recklingh[a-z 0-9]*
immernoch nicht mit
recklinhsn orthlostr nr 190
Zum Vergrößern anklicken....
Ist das nur 'n Tippfehler das da kein g drin ist? (warum kopierst du nicht und fügst ein?)

Oklino hat gesagt.:
Code: 
static const boost::regex e(strE);
Zum Vergrößern anklicken....
Du weißt aber schon was static bedeutet?

Hast du dir den reg. Ausdruck und den String mal ausgeben lassen?
Code: 
cerr << e.str()
Gruß
 
deepthroat hat gesagt.:
Ist das nur 'n Tippfehler das da kein g drin ist? (warum kopierst du nicht und fügst ein?)

Du weißt aber schon was static bedeutet?

Hast du dir den reg. Ausdruck und den String mal ausgeben lassen?
Code: 
cerr << e.str()
Gruß
Zum Vergrößern anklicken....
zu 1: war nen Tippfehler. Die Ausdrücke werden ja ~dynamisch~ erzeugt. deswegen hab ich nicht kopiert.

zu 2: jetzt ja... *ouch*

zu 3. die inhalte sind wie oben (mit dem Tippfehler das ;) ) (wobei ich mir nur strE habe ausgeben lassen - was wohl der fehler war)
-----------------------------------------------------------------------------------------------

nach dem Entfernen von static const...:

ich fasse es nicht !! der geht ^^ *löl* danke *knutsch* es geht ^^ (etliche Stunden saß ich davor... DANKE :D :D :D )
 
Um antworten zu können musst du eingeloggt sein.

Neue Beiträge

Zurück