Megosztás a következőn keresztül:

Reguláris kifejezések (C++/CLI)

A .NET-keretrendszer reguláris kifejezésosztályait használó különböző sztringműveleteket mutat be.

Az alábbi témakörök bemutatják a .NET-keretrendszer System.Text.RegularExpressions névterének (és egy esetben a System.String.Split metódusnak) a sztringek keresésére, elemzésére és módosítására való használatát.

Sztringek elemzése reguláris kifejezésekkel

Az alábbi példakód egyszerű sztringelemzést mutat be a Regex névtérben lévő System.Text.RegularExpressions osztály használatával. Egy több típusú szóelválasztót tartalmazó sztring jön létre. A sztringet a Regex osztály és a Match osztály együttes használatával elemzik. Ezután a mondatban lévő összes szó külön jelenik meg.

példa

// 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;
}

Sztringek elemzése a felosztási módszerrel

Az alábbi példakód bemutatja, hogy a System.String.Split metódussal kinyeri az egyes szavakat egy sztringből. Egy több típusú szóelválasztót tartalmazó sztring jön létre, majd a delineatorok listájával való hívással Split elemezhető. Ezután a mondatban lévő összes szó külön jelenik meg.

példa

// 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;
}

Reguláris kifejezések használata egyszerű egyeztetéshez

Az alábbi példakód reguláris kifejezéseket használ a pontos részszűrési egyezések kereséséhez. A keresést a statikus IsMatch módszer hajtja végre, amely két sztringet vesz fel bemenetként. Az első a keresendő sztring, a második pedig a keresendő minta.

példa

// 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;
}

Reguláris kifejezések használata adatmezők kinyeréséhez

Az alábbi példakód bemutatja, hogy a reguláris kifejezések használatával kinyerhetők adatok egy formázott sztringből. Az alábbi példakód egy e-mail-címnek megfelelő minta megadására használja az Regex osztályt. Ez a minta olyan mezőazonosítókat tartalmaz, amelyek az egyes e-mail címek felhasználói és állomásnév részeinek lekérésére használhatók. Az Match osztály a tényleges mintaegyezés végrehajtására szolgál. Ha a megadott e-mail cím érvényes, a rendszer kinyeri és megjeleníti a felhasználónevet és a gazdagépneveket.

példa

// 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;
}

Reguláris kifejezések használata az adatok átrendezéséhez

Az alábbi példakód bemutatja, hogyan használható a .NET-keretrendszer reguláris kifejezéstámogatása az adatok átrendezésére vagy újraformázására. Az alábbi példakód a Regex és Match osztályok használatával először kinyeri a kereszt- és vezetékneveket egy sztringből, majd ezeket a névelemeket fordított sorrendben jeleníti meg.

Az Regex osztály az adatok aktuális formátumát leíró reguláris kifejezés létrehozására szolgál. A két nevet feltételezzük, hogy vessző választja el egymástól, és tetszőleges mennyiségű fehér területet használhat a vessző körül. A Match metódus ezután az egyes sztringek elemzésére szolgál. Ha sikeres, a rendszer lekéri a vezeték- és utóneveket az Match objektumból, és megjelenik.

példa

// 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;
}

Az alábbi példakód bemutatja, hogyan használható a reguláris kifejezésosztály Regex a keresés és a csere végrehajtására. Ez a módszerrel történik Replace . A használt verzió bemenetként két sztringet használ: a módosítandó sztringet, és a beillesztendő sztringet az objektumnak Regex adott mintának megfelelő szakaszok helyett (ha vannak ilyenek).

Ez a kód egy sztring összes számjegyét aláhúzásjelekre (_) cseréli, majd üres sztringre cseréli őket, így gyakorlatilag eltávolítja őket. Ugyanez a hatás egyetlen lépésben is elvégezhető, de itt két lépést használunk bemutató célokra.

példa

// 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;
}

Reguláris kifejezések használata az adatformázás ellenőrzéséhez

Az alábbi példakód bemutatja, hogy a sztringek formázásának ellenőrzéséhez rendszeres kifejezések használhatók. Az alábbi példakódban a sztringnek érvényes telefonszámot kell tartalmaznia. Az alábbi példakód a "\d{3}-\d{3}-\d{4}" sztringet használja annak jelzésére, hogy minden mező érvényes telefonszámot jelöl. A sztringben a "d" egy számjegyet jelöl, az egyes "d" utáni argumentumok pedig a jelen lévő számjegyek számát jelzik. Ebben az esetben a számot szaggatott vonallal kell elválasztani.

példa

// 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;
}

.NET-keretrendszer reguláris kifejezései

Lásd még

.NET-programozás C++/CLI használatával (Visual C++)

  • Last updated on