Ich sollte noch erwähnen das ich Anfänger bin.

main - gibt ab dem zweiten Parameter aus der Kommandozeile jeden
Parameter auf einer eigenen Zeile aus, der das folgende Muster enthält:
"^b.*b1[0-9]"
Bei einer Kommandozeile der Form:
prog -abb1ff b1999 b---b19$$ bb156ckkk9r aprogb
soll ausgegeben werden:
b---b19$$
bb156ckkk9r

Soweit bin ich schon.

#include <iostream>
#include <cstddef>
#include <cctype>
using namespace std;

int main(int argc, char const **argv) {
const char **p(argv);
 for (int i(1); **p; i++) {
  if (**p[i][0] == 'b') {
   for (int j(1); **p[i][j]; j++) {
    if (**p[i][j]=='b' &&
        **p[i][j+1]=='1' &&
        isdigit(**p[i][j+2])){
        break;
        cout << **p << endl;
     }
    } else continue;
   } 
  } else continue;
 }
  return 0;
}

Ich kriege folgende Fehler, ich verstehe diesen zeigerkramm theoretisch, aber wenn es in die Praxis geht.

invalid type argument of ‘unary *â€
Prog.cpp:26: error: invalid type argument of ‘unary *â€
Prog.cpp:27: error: invalid type argument of ‘unary *â€
Prog.cpp:28: error: invalid type argument of ‘unary *â€
Prog.cpp:29: error: invalid type argument of ‘unary *â€
Prog.cpp:33: error: expected ‘}†before ‘elseâ€
Prog.cpp: At global scope:
Prog.cpp:35: error: expected unqualified-id before ‘elseâ€
Prog.cpp:36: error: expected declaration before ‘}†token

Danke schon im vorrauss

Ich schlage vor, du fängst nochmal ganz von vorne an. Als erstes überlegst du dir, wie du prüfen kannst, ob ein String deinem Muster entspricht. Dann kannst du die Prüfung in einer Schleife auf alle argv-Elemente anwenden.

Ich habe auch die lösung, aber da verwendet er doppelte Dereferenzierungsoperatoren(**), da blick ich dann auch nicht mehr durch.

Mein problem ist das ich nicht verstehe wie ich (wenn mann sich als array vorstellt) in den "zeilen" danach suchen soll, in der lösung regelt er das mit Pointern (**pp), hier hab ich das mit den 2 Addressop.*p[][] versucht das scheint aber nicht zu klappen, deswegen auch die fehlermeldungen.
Wie würdet Ihr das lösen?

Die lösung sieht ungefähr so aus:

int main (int argc, char** argv){

for(char const**pp(argv+1); *pp; ++pp){ // argv[i] wird durchlaufen, glaube ich
 char const *p(*pp); // fragt mich nicht  :confused: 
 if(*p != 'b')continue; 
// argv[1][0] ob 1. zeichen ein 'b' wenn nicht zuück zu for-S.
 ++p; // nächste zeichen (argv[i][i+1])
 for(; *p; ++p){ // innnere argv (zeilen)
  if(*p == 'b' && *(p+1) == '1' && isdigit(*(p+2)))break; // Muster
 }
 if(!*p)continue; // Zeichenkette länger dann weiter bei for-S.
 cout << *pp << endl; // ausgabe
}
return 0;
}

gast23 schrieb:

genau, ich möchte nach Regulären Ausdrücken(Muster: *^b.b1[0-9 ) suchen Block-/Wortweise, und dann ausgeben die schwierigkeit ist das man dass mit Zeigern machen soll.

Wieso sollte das eine zusätzliche Schwierigkeit sein? (außer der Tatsache, daß damit Lösungen auf der Basis std::string wegfallen)

PS: Du lernst nicht zufällig aus einem J.W.-Buch?

Kann mir den jemand wenigstens erklären wie das funktioniert, ohne die Addressoperatoren zu verwenden die Zeiger zeigen ja auf argv[1][0], aber wo zeigt **pp hin?

Eigentlich doch auch auf argv[1][0], wie kann er dann die Spalten durchlaufen in dem er pp++ schreibt/erhöht und mit p++ die Zeilen, die zeigen doch auf das gleiche char const *p(**pp), das kapier ich einfach nicht!

Nebenbei bemerkt ist dein Code ill-formed und dürfte nicht kompilieren:

int main (int argc,[b] char** argv[/b]){

for([b]char const**pp(argv+1)[/b];...

Ich verweigere mich allerdings der weiteren Diskussion, weil ich diesen furchtbaren Klammerfetischismus nicht ausstehen kann :p