über char** iterieren

[Feld]

Hallo

ich bin gerade mit ein paar schleifen beschäftigt, schaffe aber nicht diese unter kontrolle zu bringen - vielleicht kann jemand mir da etwas nachhelfen.

Ich habe mehrere Felder

char* name[] = { "n1", "n2", "n3", "etc" };

die sollen alle in schleifen anlaufen, sodass im endeffekt jeweils ein mal jede Kombination vorkommt - also sowas:

char* method[] = { "GET", "PUT", "POST", "HEAD" };
    char* host[] = { "H", "HOSTlaaaaaaaaaaang", "HOST3", "mehrHosts", "h5" };
    float q[] = { 1.0, 0.8, 0.7, 0.5, 0.3 };
    const char* accept[] = { "zip", "7zip", "media", "rar" };
    int i = 0, j= 0;
    float * f = &q[0] - 1;

    for ( i = 0; i < sizeof ( method ) / sizeof ( char* ); ++i )
	{
		for ( j = 0; j < sizeof ( host ) / sizeof ( char* ); ++j )
		{
			while ( ++f != q + ( sizeof( q )/sizeof(float) ) )
			{
				printf ( "method: %s\nhost: %s\nQuality: %.2f\n", method[i], host[j], *f );
			}
		}
	}

Das erstaunlichte dabei --> jede Schleife funktioniert für sich einwandfrei - aber alle zusammen ergeben eine endlosschleife -fragt mich nicht wie es möglich ist. -Auch ohne printf ist es eine endlosschleife.

1. Kann mir einer sagen wo das Problem liegt?
2. Es wird im Endeffekt so zwischen 15 - 25 einzelne char** Felder geben, und es wäre ziemlich umständlich für jeden eine Eigene zählvariable anzulegen - wie kann ich darüber iterieren ohne eigenen Zählvariablen für jeden Feld? -genau die gleiche frage für float*?
3. Ich habe ziemlich viel mit char** adressen experementiert, bin mir aber immer noch nicht im klaren was jetzt was ist - könnte einer pls die Ausgabe unten erklären?

char* method[] = { "GET", "PUT", "POST", "HEAD" };
char* cp = method[0]; // OK
    char* cp1 = &method[0]; // WARNUNG
    char* cp2 = method; // WARNUNG
puts ( ++cp ); // ergibt "ET"
	printf ( "method: %p\nadr von &method: %p\nadr von &method[0]: %p\nadr von &method[0]+1: %p\nmethod[0]: %p\n*method[0]+1: %p\n"
	, method          // ergibt: 0x27cca0
	, &method         // ergibt: 0x27cca0
	, &method[0]      // ergibt: 0x27cca0
	, &method[0]+1    // ergibt: 0x27cca4
	, method[0]       // ergibt: 0x402000
	, *method[0]+1 ); // ergibt: 0x48

iterieren und nicht in richtung method[0][x] wie hier passiert.

in printf sieht man genau das method, &method und &method[0] genau das gleiche sind - wieso funktionieren dann die zuweisungen

char* cp1 = &method[0]; // WARNUNG
    char* cp2 = method; // WARNUNG

nicht?
und Wieso unterscheidet sich die adresse von method[0] so stark von den anderen - das ist wahrscheinlich ganz anderer Speicherbereich schon - aber es ja ein array.

Ich weiß, sind viele Fragen - Danke wenn jemand mich aufklärt. Hatte mich immer davon gedrückt c zu lernen, irgendwie mag ich die Sprache nicht :p

[;fricky]

machst du so:

#define VECTORSIZE(a) (sizeof(a)/sizeof(*a))
...
char* method[] = { "GET", "PUT", "POST", "HEAD" };
char* host[] = { "H", "HOSTlaaaaaaaaaaang", "HOST3", "mehrHosts", "h5" };
double q[] = {1.0, 0.8, 0.7, 0.5, 0.3};
int i, j, k;
...
for (i=0; i<VECTORSIZE(method); i++)
  for (j=0; j<VECTORSIZE(host); j++)
    for (k=0; k<VECTORSIZE(q); k++)
      printf ("method: %s host: %s Quality: %f\n", method[i], host[j], q[k]);
...

Feld schrieb:

Hatte mich immer davon gedrückt c zu lernen, irgendwie mag ich die Sprache nicht

dann nimm doch HTML. *fg*

[Feld]

Danke, das Makro erspart mir etwas tipparbeit, aber löst trotzdem nicht die Frage wie ich 20 Zählvariblen vermeiden kann und auch nicht nicht wieso geschachtelte while schleife nicht funktioniert.

Ich war schon mal auf die Sache mit geschachtelten wheil Schleifen gestoßen - damals sollte ich ein Programm für brute-force-angriff scjreiben, und genau wie jetzt haben die geschachtelten while schleifen nicht funktioniert, obwohl jede für sich einwandfrei arbeitete.

ps. HTML ist nicht mal eine Programmiersprache

[MiP]

while ( ++f != q + ( sizeof( q )/sizeof(float) ) )

Dein f wird bald grösser als der Vergleichswert. Dann wird deine While-Schleife zur Endlosschleife. Besser wäre wohl:

while ( ++f < q + ( sizeof( q )/sizeof(float) ) )

oder frickys Variante.

[Feld]

Da komme ich wohl nicht herum ohne 20 Zählervariablen anzulegen...

Bin mir unsicher ob ich es einfach nicht begreife, oder ob der gcc compiler so ein Schrott ist, aber aus einer while schleife in 2 forschelifen arbeitet er die innerste while schleife ab und danach die 2 forschleifen normal. also aus

f = 64;
	for ( i = 0; i < 2; ++i )
	{
		puts ( " -------- i -------------\n" );
		for ( j = 0; j < 3; ++j )
		{
            puts ( " -------- j -------------\n"  );
			while ( ++f < 70 )
			{
				printf ( "i= %d \t j = %d \t f = %c\n", i, j, f );
			}
		}
	}

gibts folgende Ausgabe:

----------- i -----------
----------- j -----------
i = 0 j = 0 f = A
i = 0 j = 0 f = B
i = 0 j = 0 f = C
i = 0 j = 0 f = D
i = 0 j = 0 f = E
----------- j -----------
----------- j -----------
----------- i -----------
----------- j -----------
----------- j -----------
----------- j -----------

→ Was sicherlich nicht das ist, was damit gemeint war. wenn ich jetzt die innere while schleife gegen eine for schleife austausche, dann läuft alles so wie es gedacht war.

hat einer eine Erklärung dafür?
( habe gerade getestet - der g++ compiler macht genau das gleiche )

[;fricky]

^^du musst f wieder zurücksetzen
zu den 20 zählern: mit einem müsste es auch gehen, so etwa:

char* method[] = { "GET", "PUT", "POST", "HEAD" };
char* host[] = { "H", "HOSTlaaaaaaaaaaang", "HOST3", "mehrHosts", "h5" };
double q[] = {1.0, 0.8, 0.7, 0.5, 0.3}; 
...
int i;
...
for (i=0; i<4*5*5; i++) 
{
  printf ("%s %s %f\n", method[i%4], host[i%5], q[i%5]);
}
...

Feld schrieb:

ps. HTML ist nicht mal eine Programmiersprache

ansichtssache, meiner meinung nach ja.

[pointercrash**]

Feld schrieb:

hat einer eine Erklärung dafür?

Ja schon, Du initialisierst f nur einmal.

[Feld]

Ja ... alles geniale ist genial einfach
Das ist so offensichtlich das es nicht funktionieren kann wenn ich nicht jedes mal f neu initialisiere das es mir nicht eingefallen war
Ok, nun dürfte es funktionieren, danke :xmas1:

[;fricky]

;fricky schrieb:

printf ("%s %s %f\n", method[i%4], host[i%5], q[i%5]);

ach, ich hab was verpeilt, so sollte das eigentlich:

printf ("%s %s %f\n", method[i%4], host[i/4%5], q[i/4/5%5]);