regex_replace $1

_ro_ro

auto const& [key,value]

error: expected unqualified-id before '[' token
     for( auto const& [key,value]  : stash ) {

Schlangenmensch

Das was @DocShoe sagt.
In Perl ist $1 der erste Match, in c++ gibt es das so nicht.

@_ro_ro , für den Vorschlag von @DocShoe musst du C++ 17 bei dem Compiler enabled haben.
Mit c++ 11 sollte das gehen (ungetestet)

for( auto const& s : stash )
{
    std::cout << std::regex_replace (s, e, s.second );
}

_ro_ro

@Schlangenmensch sagte in regex_replace $1:

Das was @DocShoe sagt.
In Perl ist $1 der erste Match, in c++ gibt es das so nicht.

doch gibt es:

https://cplusplus.com/reference/regex/regex_replace/

mfg

firefly

@_ro_ro sagte in regex_replace $1:

@Schlangenmensch sagte in regex_replace $1:

Das was @DocShoe sagt.
In Perl ist $1 der erste Match, in c++ gibt es das so nicht.

doch gibt es:

https://cplusplus.com/reference/regex/regex_replace/

mfg

Nope. Nicht so wie du es geschrieben hast. Du musst schon genauer lesen.
Aus deinem link:

 std::regex_replace (std::back_inserter(result), s.begin(), s.end(), e, "$2");

Und hier ist deine zeile

std::regex_replace (s, e, stash[$1]);

Das ist überhaupt nicht identisch was den 3. Parameter betrifft.

_ro_ro

@Schlangenmensch

fast. Aber da ist noch was im Argen:

    std::string s ("Name `name` Vname `vname` ");
    map<string, string> stash; 
    stash["name"] = "Hansel";
    stash["vname"] = "Ulrich";
    std::regex e ( "`(\\w+)`" ) ; 

    for( auto const& st  : stash ) {
       std::cout << std::regex_replace (s, e, st.second  ) << "\n";
    }

Gibt aus:

Name Hansel Vname Hansel 
Name Ulrich Vname Ulrich

Also stimmt mit der Zurodnung was nicht. Was ich beabsichtige sollte eigentlich klar sein: Das Template soll ja nur einmal (!) gerendert werden und mit dem Ersetzungen am rechten Platz.

(!) Da ist die Schleife ja schon ein falscher Ansatz

Name Hansel Vname Ulrich

Viele Grüße!

Th69

std::regex_replace gibt den geänderten String zurück, deine Schleife operiert aber immer nur auf dem Originalstring s. Du mußt also s neu zuweisen.

DocShoe

Ich glaube, du kannst immer nur ein Vorkommen gleichzeitig ersetzen, dazu musst du doch alle Einträge per Schleife durchlaufen und separat ersetzen:

std::string const templ = "Name `name` Vname `vname`";
std::map<std::string, std::string> const stash { { "name", "Hansel" }, { "vname", "Ulrich" } };

std::string output = templ;	
for( auto const& [key, value] : stash )
{
   std::regex r( "`" + key + "`" );
   output = std::regex_replace( output, r, value );
}
std::cout << output << "\n";

_ro_ro

@Th69 sagte in regex_replace $1:

std::regex_replace gibt den geänderten String zurück, deine Schleife operiert aber immer nur auf dem Originalstring s. Du mußt also s neu zuweisen.

Ja is schon klar. Die Frage ist nur wie

MFG

wob

Moin!

Regex-Strings kann man in C++ am besten mit einem R-String schreiben, damit man nicht überall die Backslashes quoten muss. Zum Beispiel so:
Dein

"`(\\w+)`"
// ist 
R"(`(\w+)`)"
// oder auch:
R"***(`(\w+)`)***"

Du kannst den String zwischen " und ( so wählen, dass das Ende-Zeichen sicher nicht im String vorkommt.

Regexes in C++ benutzen sich so "mäh", wenn man das aus Perl gewöhnt ist. Man kann mit einem regex_token_iterator arbeiten, ungefähr so:

string text { "Name `name` Vname `vname` " };
regex re { R"*(`(\w+)`)*" };
for_each(
    sregex_token_iterator(begin(text), end(text), re, {0, -1}),
    sregex_token_iterator{},
    [](const string &s){cout << s << "\n";}
);

Ist aber blöd, weil du abwechselnd die Matches und Zwischenteile bekommst (oder wahlweise nur die Matches, wenn du das -1 weglässt). Ich glaube, dass man sich da also was selbst basteln muss (vielleicht auch nur mit dem regex_iterator?). Ich habe std::regex immer versucht zu vermeiden.

Weil man oft gar keine regexes braucht, die man zur Laufzeit zusammenstellen kann (ist eh recht teuer), gibt es auch eine spannende Compilezeit-Regex-Bibliothek von Hanka Dusikova: https://github.com/hanickadot/compile-time-regular-expressions

_ro_ro

@wob

Danke @wob das wird ne wüste Frickelei

Also mir geht es darum, meine Templating Engine performanter zu machen. Die geht Zeichen für Zeichen durch das Template um die String-Begrenzer (da habe ich mich für Backticks entschieden) und damit die Platzhalter zu finden. Das Ganze läuft stabil und ermöglicht eine Fehlerbehandlung wenn die Syntax des Template nicht stimmt.

Wahrscheinlich ists das Beste, es so zu belassen. Performance ist nicht immer das Kriterium.

Viele Grüße.

wob

@_ro_ro In Boost geht das, was du willst: https://www.boost.org/doc/libs/1_84_0/libs/regex/doc/html/boost_regex/ref/regex_replace.html (das Formatter kann dort eine Funktion sein)

_ro_ro

@wob sagte in regex_replace $1:

@_ro_ro In Boost geht das, was du willst: https://www.boost.org/doc/libs/1_84_0/libs/regex/doc/html/boost_regex/ref/regex_replace.html (das Formatter kann dort eine Funktion sein)

Ja danke Dir. Boost kenn' ich auch schon

Und wie nochmal verspeist man einen Elefanten? Stück für Stück

Viele Grüße1!!

DocShoe

@_ro_ro

Das ist doch kein Hexenwerk, sich sowas schnell selbst zu schreiben.

wob

@DocShoe sagte in regex_replace $1:

Das ist doch kein Hexenwerk, sich sowas schnell selbst zu schreiben.

Naja, ich finde es nicht so einfach. Diese Funktionalität fehlt einfach in std::regex. Klar, für diesen speziellen Fall hat man selbst schnell was geklöppelt.

Oder eben mit boost:

#include <boost/regex.hpp>
#include <map>
#include <string>
#include <iostream>

int main() {
    using namespace std;

    map<string, string> repl = {{"name", "Ulrich"}, {"vname", "Hansel"}};

    string text { "Name `name` Vname `vname` " };
    boost::regex re { R"*(`(\w+)`)*" };

    string result = boost::regex_replace(text, re, [&](const boost::smatch &m) { return repl.at(m[1]); } );
    cout << result << '\n';
}

_ro_ro

@wob

Ja, sehr schön. Wie sieht die Fehlerbehandlung aus wenn im Template die Syntax nicht stimmt? Wenn z.B. an einem Platzhalter ein Backtick vergessen wurde?

MFG

Th69

Du meinst, wenn kein Text ersetzt werden konnte?
Entweder (bezogen auf den Code von @wob) den String vergleichen:

if (result == text)
    // ...

oder aber ein Flag setzen:

bool changed = false;
string result = boost::regex_replace(text, re, [&](const boost::smatch &m) { changed = true; return repl.at(m[1]); } );
if (!changed)
    // ...

DocShoe

@_ro_ro
Hab mal was gebastelt, kannst ja mal schauen, ob's funktioniert. Und wie's performancetechnisch im Vergleich zu regex aussieht:

#include <string>
#include <map>
#include <algorithm>
#include <stdexcept>

std::string replace_copy( std::string const& templ,
                          std::string::value_type delimiter,
                          std::map<std::string, std::string> const substitutions )
{
   std::string retval;
   for( auto it = templ.begin(); it != templ.end(); )
   {
      // Delimiter finden und alles bis zum Delimiter in Ergebnis übernehmen
      auto pos = std::find( it, templ.end(), delimiter );
      retval.insert( retval.end(), it, pos );

      // existieren weitere Zeichen?
      if( pos != templ.end() )
      {
         // ja, pos steht auf dem öffnenden Trennzeichen, Platzhalter beginnt mit dem folgendem Zeichen
         ++pos;

         // ab erstem Platzhalterzeichen das schließende Trennzeichen suchen
         auto end = std::find( pos, templ.end(), delimiter );
         if( end == templ.end() )
         {
            throw std::invalid_argument( "Missing terminal delimiter." );
         }
         // end steht auf dem schließenden Trennzeichen
         std::string const name( pos, end );
         auto sub = substitutions.find( name );
         if( sub == substitutions.end() )
         {
            throw std::invalid_argument( "Unknown placeholder '" + name + "'." );
         }			
         // Wert übernehmen
         retval += sub->second;
	
         // end steht auf Delimiter, ab folgendem Zeichen weitersuchen		
         it = ++end;
      }
   }
   return retval;
}

Grundsätzlich sollte man aber schon fertige Lösungen bervorzugen. Hab leider keine Möglichkeit gefunden, wie man string_viewals Lookup benutzt, dann könnte man sich den std::string in Zeile 30 sparen.

_ro_ro

@DocShoe

Funktioniert einwandfrei, vielen Dank!!!
++ für die Prüfung ob ein Platzhalter bekannt ist!

MFG

PS:: Die Konsistenzprüfung können wir vereinfachen, einfach die Delimiter (Stringbegrenzer) zählen. Die Summe muß eine gerade Zahl ergeben
Ansonsten einer erstklassige Alternative für sprintf! Schluss mit der Stringverkettungsfummelei

_ro_ro

@DocShoe

der Vollstkt. halber. Meine Lösung:

namespace Templating{
    // Einfache Platzhalter in Backticks
    class Simple{
        private:
        string TEMPL;
        map <string, string> STASH;
        size_t cur_pos;  // Current pos in Template           
        string result;
        size_t pcount;   // Zähler Backticks
        string cur_name; // Current Name Platzhalter

        public:
        string encode_entities(const string &str){
            string res;
            for(int i = 0; i < str.length(); i++){
                string s = str.substr(i,1);
                if( s.compare("<") == 0 ) res += "&lt;";
                else if( s.compare("'") == 0  ) res += "&x#27;";
                else if( s.compare("\"") == 0  ) res += "&x#22;";
                else if( s.compare("&") == 0  ) res += "&amp;";
                else res += s; 
            }
            return res;
        };
        // extrahiere Name des Platzhalters
        void exname(){
            string s;
            cur_name = "";
            for(; cur_pos < TEMPL.length(); cur_pos++){
                s = TEMPL.substr(cur_pos,1);
                if( s.compare("`") == 0 ) {
                    pcount++;
                    break;
                }
                cur_name += s;
            }
            result += encode_entities( STASH[cur_name] );
        };

        string render(){
            for(cur_pos = 0 ; cur_pos < TEMPL.length(); cur_pos++){
                string s = TEMPL.substr(cur_pos, 1);
                if( s.compare("`") == 0 && pcount % 2 == 0){
                    pcount++;
                    cur_pos++;
                    exname();
                }
                else result += s;
            }
            if ( pcount % 2 ) throw string("Template Syntaxfehler. Die Anzahl der Backticks geht nicht auf, bitte prüfen!");
            return result;
        };

        // Konstruktor
        Simple(const string &templ, const map<string,string> &names){
            TEMPL = templ;
            STASH = names;   
            cur_pos = 0;
            pcount = 0;
        };
    };// class TE Templating Engine

wob

@_ro_ro sagte in regex_replace $1:

Schluss mit der Stringverkettungsfummelei

Vielleicht willst du dir auch mal https://github.com/fmtlib/fmt anschauen. Ab C++20 bzw. C++23 auch im Standard vorhanden. Das ist dann mehr im Python-Stil und meiner Meinung nach viel besser lesbar als stream << ver << "kett" << ungen, vor allem weil man bei den Streams nie weiß, was passiert, wenn man z.B. eine Zahl schreibt (das hängt dann davon ab, ob jemand vorher irgendein Format gesetzt hat)

PS:
In deinem Code

string s = str.substr(i,1);
if( s.compare("<") == 0 ) ...

Was soll das werden?!
Du hast einen 1-Zeichen langen String. Das ist ein char. Und warum compare statt == - oder, da das ja eigentlich ein char ist - warum nicht ein switch? Und das encode_entities sollte irgedwie eine allgemeine Funktion sein, man braucht ja keine Templating-Engine dafür.

Achtung: Strings wissen nichts von der Kodierung! Also immer Vorsicht bei der Verarbeitung über je 1 char.