Reguläre Ausdrücke (C++/CLI)

Veranschaulicht verschiedene Zeichenfolgenvorgänge mit regulären Ausdrücken klassen im .NET Framework.

In den folgenden Themen wird die Verwendung des .NET Framework-Namespace System.Text.RegularExpressions (und in einem Fall die System.String.Split Methode) zum Suchen, Analysieren und Ändern von Zeichenfolgen veranschaulicht.

Analysieren von Zeichenfolgen mit regulären Ausdrücken

Im folgenden Codebeispiel wird die einfache Zeichenfolgenanalyse mithilfe der Regex-Klasse im System.Text.RegularExpressions-Namespace veranschaulicht. Eine Zeichenfolge mit mehreren Arten von Wortdelineatoren wird erstellt. Die Zeichenfolge wird dann mit der Regex-Klasse in Verbindung mit der Match-Klasse analysiert. Anschließend werden alle Wörter des Satzes getrennt angezeigt.

Beispiel

// regex_parse.cpp
// compile with: /clr
#using <system.dll>

using namespace System;
using namespace System::Text::RegularExpressions;

int main( )
{
   int words = 0;
   String^ pattern = "[a-zA-Z]*";
   Console::WriteLine( "pattern : '{0}'", pattern );
   Regex^ regex = gcnew Regex( pattern );

   String^ line = "one\ttwo three:four,five six  seven";
   Console::WriteLine( "text : '{0}'", line );
   for( Match^ match = regex->Match( line );
        match->Success; match = match->NextMatch( ) )
   {
      if( match->Value->Length > 0 )
      {
         words++;
         Console::WriteLine( "{0}", match->Value );
      }
   }
   Console::WriteLine( "Number of Words : {0}", words );

   return 0;
}

Analysieren von Zeichenfolgen mithilfe der Split-Methode

Im folgenden Codebeispiel wird die Verwendung der System.String.Split-Methode veranschaulicht, um alle Wörter einer Zeichenfolge zu extrahieren. Eine Zeichenfolge mit mehreren Arten von Wortdelineatoren wird generiert und dann durch Aufrufen von Split mit einer Liste der Delineatoren analysiert. Anschließend werden alle Wörter des Satzes getrennt angezeigt.

Beispiel

// regex_split.cpp
// compile with: /clr
using namespace System;

int main()
{
   String^ delimStr = " ,.:\t";
   Console::WriteLine( "delimiter : '{0}'", delimStr );
   array<Char>^ delimiter = delimStr->ToCharArray( );
   array<String^>^ words;
   String^ line = "one\ttwo three:four,five six seven";

   Console::WriteLine( "text : '{0}'", line );
   words = line->Split( delimiter );
   Console::WriteLine( "Number of Words : {0}", words->Length );
   for (int word=0; word<words->Length; word++)
      Console::WriteLine( "{0}", words[word] );

   return 0;
}

Verwenden regulärer Ausdrücke für einfachen Abgleich

Im folgenden Codebeispiel werden reguläre Ausdrücke verwendet, um nach exakten Teilzeichenfolgenüberstimmungen zu suchen. Die Suche wird von der statischen IsMatch Methode ausgeführt, die zwei Zeichenfolgen als Eingabe akzeptiert. Die erste ist die zu durchsuchende Zeichenfolge, und die zweite ist das Muster, nach dem gesucht werden soll.

Beispiel

// regex_simple.cpp
// compile with: /clr
#using <System.dll>

using namespace System;
using namespace System::Text::RegularExpressions;

int main()
{
   array<String^>^ sentence =
   {
      "cow over the moon",
      "Betsy the Cow",
      "cowering in the corner",
      "no match here"
   };

   String^ matchStr = "cow";
   for (int i=0; i<sentence->Length; i++)
   {
      Console::Write( "{0,24}", sentence[i] );
      if ( Regex::IsMatch( sentence[i], matchStr,
                     RegexOptions::IgnoreCase ) )
         Console::WriteLine("  (match for '{0}' found)", matchStr);
      else
         Console::WriteLine("");
   }
   return 0;
}

Verwenden regulärer Ausdrücke zum Extrahieren von Datenfeldern

Das folgende Codebeispiel veranschaulicht die Verwendung regulärer Ausdrücke zum Extrahieren von Daten aus einer formatierten Zeichenfolge. Im folgenden Codebeispiel wird die Regex Klasse verwendet, um ein Muster anzugeben, das einer E-Mail-Adresse entspricht. Dieser Patter enthält Feldbezeichner, die zum Abrufen der Benutzer- und Hostnamenabschnitte jeder E-Mail-Adresse verwendet werden können. Die Match Klasse wird verwendet, um den tatsächlichen Musterabgleich durchzuführen. Wenn die angegebene E-Mail-Adresse gültig ist, werden der Benutzername und die Hostnamen extrahiert und angezeigt.

Beispiel

// Regex_extract.cpp
// compile with: /clr
#using <System.dll>

using namespace System;
using namespace System::Text::RegularExpressions;

int main()
{
    array<String^>^ address=
    {
        "jay@southridgevideo.com",
        "barry@adatum.com",
        "treyresearch.net",
        "karen@proseware.com"
    };

    Regex^ emailregex = gcnew Regex("(?<user>[^@]+)@(?<host>.+)");

    for (int i=0; i<address->Length; i++)
    {
        Match^ m = emailregex->Match( address[i] );
        Console::Write("\n{0,25}", address[i]);

        if ( m->Success )
        {
            Console::Write("   User='{0}'",
            m->Groups["user"]->Value);
            Console::Write("   Host='{0}'",
            m->Groups["host"]->Value);
        }
        else
            Console::Write("   (invalid email address)");
        }

    Console::WriteLine("");
    return 0;
}

Verwenden regulärer Ausdrücke zum Neuanordnen von Daten

Im folgenden Codebeispiel wird veranschaulicht, wie die Unterstützung regulärer Ausdrücke von .NET Framework zum Neuanordnen oder Neuformatieren von Daten verwendet werden kann. Im folgenden Codebeispiel werden die Regex Und-Klassen Match verwendet, um Vor- und Nachnamen aus einer Zeichenfolge zu extrahieren und diese Namenselemente dann in umgekehrter Reihenfolge anzuzeigen.

Die Regex Klasse wird verwendet, um einen regulären Ausdruck zu erstellen, der das aktuelle Format der Daten beschreibt. Es wird davon ausgegangen, dass die beiden Namen durch ein Komma getrennt werden und eine beliebige Menge Leerzeichen um das Komma verwenden können. Anschließend Match wird die Methode verwendet, um jede Zeichenfolge zu analysieren. Bei erfolgreicher Ausführung werden Vornamen und Nachnamen aus dem Match Objekt abgerufen und angezeigt.

Beispiel

// regex_reorder.cpp
// compile with: /clr
#using <System.dll>
using namespace System;
using namespace Text::RegularExpressions;

int main()
{
   array<String^>^ name =
   {
      "Abolrous, Sam",
      "Berg,Matt",
      "Berry , Jo",
      "www.contoso.com"
   };

   Regex^ reg = gcnew Regex("(?<last>\\w*)\\s*,\\s*(?<first>\\w*)");

   for ( int i=0; i < name->Length; i++ )
   {
      Console::Write( "{0,-20}", name[i] );
      Match^ m = reg->Match( name[i] );
      if ( m->Success )
      {
         String^ first = m->Groups["first"]->Value;
         String^ last = m->Groups["last"]->Value;
         Console::WriteLine("{0} {1}", first, last);
      }
      else
         Console::WriteLine("(invalid)");
   }
   return 0;
}

Verwenden regulärer Ausdrücke zum Suchen und Ersetzen

Im folgenden Codebeispiel wird veranschaulicht, wie die Klasse Regex für reguläre Ausdrücke zum Ausführen von Suchen und Ersetzen verwendet werden kann. Dies geschieht mit der Replace Methode. Die verwendete Version verwendet zwei Zeichenfolgen als Eingabe: die zu ändernde Zeichenfolge und die Zeichenfolge, die anstelle der Abschnitte eingefügt werden soll (falls vorhanden), die dem dem Objekt zugewiesenen Regex Muster entsprechen.

Dieser Code ersetzt alle Ziffern in einer Zeichenfolge durch Unterstriche (_) und ersetzt diese dann durch eine leere Zeichenfolge, wodurch sie effektiv entfernt werden. Derselbe Effekt kann in einem einzigen Schritt erreicht werden, aber hier werden zwei Schritte für Demonstrationszwecke verwendet.

Beispiel

// regex_replace.cpp
// compile with: /clr
#using <System.dll>
using namespace System::Text::RegularExpressions;
using namespace System;

int main()
{
   String^ before = "The q43uick bro254wn f0ox ju4mped";
   Console::WriteLine("original  : {0}", before);

   Regex^ digitRegex = gcnew Regex("(?<digit>[0-9])");
   String^ after = digitRegex->Replace(before, "_");
   Console::WriteLine("1st regex : {0}", after);

   Regex^ underbarRegex = gcnew Regex("_");
   String^ after2 = underbarRegex->Replace(after, "");
   Console::WriteLine("2nd regex : {0}", after2);

   return 0;
}

Verwenden regulärer Ausdrücke zum Überprüfen der Datenformatierung

Im folgenden Codebeispiel wird die Verwendung regulärer Ausdrücke veranschaulicht, um die Formatierung einer Zeichenfolge zu überprüfen. Im folgenden Codebeispiel sollte die Zeichenfolge eine gültige Telefonnummer enthalten. Im folgenden Codebeispiel wird die Zeichenfolge "\d-\d{3}{3}-\d{4}" verwendet, um anzugeben, dass jedes Feld eine gültige Telefonnummer darstellt. The "d" in the string indicates a digit, and the argument after each "d" indicates the number of digits that must be present. In diesem Fall muss die Zahl durch Gedankenstriche getrennt werden.

Beispiel

// regex_validate.cpp
// compile with: /clr
#using <System.dll>

using namespace System;
using namespace Text::RegularExpressions;

int main()
{
   array<String^>^ number =
   {
      "123-456-7890",
      "444-234-22450",
      "690-203-6578",
      "146-893-232",
      "146-839-2322",
      "4007-295-1111",
      "407-295-1111",
      "407-2-5555",
   };

   String^ regStr = "^\\d{3}-\\d{3}-\\d{4}$";

   for ( int i = 0; i < number->Length; i++ )
   {
      Console::Write( "{0,14}", number[i] );

      if ( Regex::IsMatch( number[i], regStr ) )
         Console::WriteLine(" - valid");
      else
         Console::WriteLine(" - invalid");
   }
   return 0;
}

Verwandte Abschnitte

Reguläre Ausdrücke von .NET Framework

Siehe auch

.NET Programming with C++/CLI (Visual C++) (.NET-Programmierung mit C++/CLI (Visual C++))