...
int test[3];
test[0]=5;
test[1]=62;
test[2]=7;
...

versteh ich das noch.
Allerdings kamen dann mehrdimensionale Felder die nicht mehr in dieser Form zugewiesen worden zum Beispiel so;

...
int test[][3][2]=
{
        {{1},{3,4},{5,6}},
        {{7,8},{9,10},{11,12}}
};
.....
cout << " " << int (test[0][0][0]);
cout << " " << int (test[0][0][1]);
usw...

als ausgabe erscheint dann zb:

1 0

So also entweder ich bin zu doof oder hab etwas Grundlegendes nicht verstanden.
Auf jeden Fall kann ich es nicht nachvollziehen. Wäre super wenn mir jemand eine Erklärung dazu geben könnte die auch ein Anfänger wie ich versteht.
Danke schonmal

int test[][3][2]=
{
        {{1},{3,4},{5,6}},
        {{7,8},{9,10},{11,12}}
};

ist in Wirklichkeit:

int test[][3][2]=
{
        {{1,**},{3,4},{5,6}},
        {{7,8},{9,10},{11,12}}
};

(Da wo ** steht steht halt das was da steht da du es nicht initialisierst ... kann auch sein das da 0 steht - garantieren kann dir das CrossCompiler aber keiner.) --> (Da wo ** steht steht halt das was da [VOHER AUF DEM STACK SCHON STAND] da du es nicht initialisierst ... [ES] kann auch sein das da 0 [STAND] - garantieren kann dir das [ÜBER VERSCHIEDENE COMPILER/BETRIEBSSYSTEME HINWEG ABER] keiner.)

Du Baust da einen Array dessen Erste Größe aus der Initialisierung die dahinter kommt, ermittelt wird. Der zweite Index ist 3 groß, der dritte 2. Das Selbe Ergebnis hast du bei

int test[][][2]=
{
        {{1,-2},{3,4},{5,6}},
        {{7,8},{9,10},{11,12}}
};

oder

int test[][][]=
{
        {{1,-2},{3,4},{5,6}},
        {{7,8},{9,10},{11,12}}
};

Vielleicht wirds so deutlicher:

int test[][][]=
{ // erste dim == 2
        { // zweite dim == 3
                { // dritte dim == 2
                        1,-2
                }, 
                { // dritte dim == 2
                        3,4
                }, 
                { // dritte dim == 2
                        5,6
                }
        },
        { // zweite dim == 3,
                { // dritte dim == 2
                        7,8
                },
                { // dritte dim == 2
                        9,10
                },
                { // dritte dim == 2
                        11,12
                }
        }
};

int test[][3][2]=
{
        {{1,**},{3,4},{5,6}},
        {{7,8},{9,10},{11,12}}
};

Da wo ** steht steht halt das was da steht da du es nicht initialisierst ... kann auch sein das da 0 steht - garantieren kann dir das CrossCompiler aber keiner.

Verwirrter Satz.
Es werden weniger Elemente in der Initialisierung angegeben als die explizit angegebene Grösse des arrays - also werden alle nicht angegebenen Elemente mit 0 initialisiert. Sehe ich kein Problem.

@Pafi - was genau verstehst du denn nicht?

cout << " " << int (test[0][0][1])

eine 0 ist oder

cout << " " << int (test[1][2][1])

dann eine 12

padreigh schrieb:

Da wo ** steht steht halt das was da [VOHER AUF DEM STACK SCHON STAND] da du es nicht initialisierst ... [ES] kann auch sein das da 0 [STAND] - garantieren kann dir das [ÜBER VERSCHIEDENE COMPILER/BETRIEBSSYSTEME HINWEG ABER] keiner.

Verwirrter Satz.

Besser? Und wer stellt bei PODs diese 0 sicher? Imho keiner - also steht da was auch immer vorher im Stack dort stand ... mag mich aber auch irren.

Also ich komme nicht von C#. Ich hab mir eingebildet einfach mal mit Hilfe ein paar Bücher C++ zu "lernen". Vielleicht ne schwachsinnige Idee aber wo ein Wille da auch ein Weg hoffe ich zumindest. Die Ausschnitte wie ich sie gepostet habe stehen so im Buch. Mir fehlt einfach die Logik warum zb.

cout << " " << int (test[0][0][1])

eine 0 ist oder

cout << " " << int (test[1][2][1])

dann eine 12

Anm: Statt [code ][/code ] besser [cpp ][/cpp ]

[c]cout << " " << int (test[0][0][1])[/c] gibt dir hier -2 zurück:
[cpp]innt test[][][]=
{
{ // ERSTER INDEX: 0
{ // ZWEITER INDEX: 0
1, // DRITTER INDEX: 0
-2 // DRITTER INDEX: 1 // HIER FEHLT BEI DIR DER WERT WESHALB DORT m.E. WAS ZUFÄLLIGES STEHTEN KANN. BEI DIR HALT GERADE 0.
},
{ // ZWEITER INDEX: 1
3,4
},
{ // ZWEITER INDEX: 2
5,6
}
},

{ // ERSTER INDEX: 1
{ // ZWEITER INDEX: 0
7, // DRITTER INDEX: 0
8 // DRITTER INDEX: 1
},
{ // dritte dim == 2
9,10
},
{ // dritte dim == 2
11,12
}
}
}; [/cpp]

cout << " " << int (test[0][0][1])

bekomme ich eine 0 zurück.

kann man das ganze nicht irgendwie grafisch darstellen? ich raffs irgendwie gerade nicht

Dann schau dir MEINE Initialisierung an. DU gibts keinen 2. Wert in deiner an, also ist (wenn ich mich bezüglich der defaultInit nicht irre) -EGAL WAS DU ZURÜCKBEKOMMST: Z U F Ä L L I G. Noch grafischer kann ich es in einem Textbasierten Forum ohne Bildeinfügemöglichkeit nicht machen

okay also ich glaub langsam komm ich der sache näher...ich würd sogar behaupten ich habs kapiert^^

das heißt quasi wenn ich

...
int test[][3][2]=
{
        {{0,1},{3,4},{5,6}},
        {{7,8},{9,10},{11,12}}
};
.....

programmieren würde wäre

cout << " " << int (test[0][0][0]);

eine 0
und

cout << " " << int (test[0][0][1]);

eine 1

richtig?

Vielen Dank schonmal für die schnelle Hilfe

cout << " " << int (test[0][0][2]);

?

jupp ... und was wäre

cout << " " << int (test[0][0][2]);

?

ähm in meiner logik kommt [0][0][2] irgendwie nicht vor

kanns sein dass es gar nicht geht da die anzahl der elemente nur 0 und 1 zulässt?

Wenn du üben willst, gib den mal in richtiger Reihenfolge aus:

int main()
{
    int arr [2][3][2][4][1] =
    { 
        {{{{26},{11},{2},{28}},{{4},{13},{30},{17}}},{{{6},{15},{32},{33}},{{23},{8},{37},{34}}},{{{39},{10},{19},{36}},{{41},{12},{9},{38}}}},
        {{{{40},{14},{43},{45}},{{16},{42},{47},{46}}},{{{18},{44},{1},{31}},{{35},{3},{20},{29}}},{{{27},{5},{22},{21}},{{7},{25},{24},{48}}}}
    };

   std::cout
 << arr[][][][][0] << arr[][][][][0] << arr[][][][][0] << arr[][][][][0] << arr[][][][][0] << arr[][][][][0] << arr[][][][][0] << arr[][][][][0]
 << arr[][][][][0] << arr[][][][][0] << arr[][][][][0] << arr[][][][][0] << arr[][][][][0] << arr[][][][][0] << arr[][][][][0] << arr[][][][][0]
 << arr[][][][][0] << arr[][][][][0] << arr[][][][][0] << arr[][][][][0] << arr[][][][][0] << arr[][][][][0] << arr[][][][][0] << arr[][][][][0]
 << arr[][][][][0] << arr[][][][][0] << arr[][][][][0] << arr[][][][][0] << arr[][][][][0] << arr[][][][][0] << arr[][][][][0] << arr[][][][][0]
 << arr[][][][][0] << arr[][][][][0] << arr[][][][][0] << arr[][][][][0] << arr[][][][][0] << arr[][][][][0] << arr[][][][][0] << arr[][][][][0]
 << arr[][][][][0] << arr[][][][][0] << arr[][][][][0] << arr[][][][][0] << arr[][][][][0] << arr[][][][][0] << arr[][][][][0] << arr[][][][][0];
}

Wenn du üben willst, gib den mal in richtiger Reihenfolge aus:

int main()
{
    int arr [2][3][2][4][1] =
    { 
        {{{{26},{11},{2},{28}},{{4},{13},{30},{17}}},{{{6},{15},{32},{33}},{{23},{8},{37},{34}}},{{{39},{10},{19},{36}},{{41},{12},{9},{38}}}},
        {{{{40},{14},{43},{45}},{{16},{42},{47},{46}}},{{{18},{44},{1},{31}},{{35},{3},{20},{29}}},{{{27},{5},{22},{21}},{{7},{25},{24},{48}}}}
    };

   std::cout
 << arr[0][0][0][0][0] << arr[0][0][0][1][0] << arr[0][0][0][2][0] << arr[0][0][0][3][0] << arr[0][0][1][0][0] << arr[0][0][1][1][0] << arr[0][0][1][2][0] << arr[0][0][1][3][0]
 << arr[0][1][0][0][0] <<<< arr[0][1][0][1][0] << arr[0][1][0][2][0] << arr[0][1][0][3][0] arr[0][1][1][0][0] << arr[0][1][1][1][0] << arr[0][1][1][2][0] << arr[0][1][1][3][0]
 << arr[0][2][0][0][0] << arr[0][2][0][1][0] << arr[0][2][0][2][0]
 << arr[0][2][0][3][0] << arr[0][2][1][0][0] << arr[0][2][1][1][0] << arr[0][2][1][2][0] << arr[0][2][1][3][0] << arr[1][0][0][0][0] << arr[1][0][0][1][0] << arr[1][0][0][2][0]
 << arr[1][0][0][3][0] << arr[1][0][1][0][0] << arr[1][0][1][1][0] << arr[1][0][1][2][0] << arr[1][0][1][3][0] << arr[1][1][0][0][0] << arr[1][1][0][1][0] << arr[1][1][0][2][0]
 << arr[1][1][0][3][0] << arr[1][1][1][0][0] << arr[1][1][1][1][0] << arr[1][1][1][2][0] << arr[1][1][1][3][0] << arr[1][2][0][0][0] << arr[1][2][0][1][0] << arr[1][2][0][2][0]
 << arr[1][2][0][3][0] << arr[1][2][1][0][0] << arr[1][2][1][1][0] << arr[1][2][1][2][0] << arr[1][2][1][3][0] ;
}

sooo. könnte stimmen zumindest gings auf^^

Ich bin gemein Jupp genau, das gibt nen Compilerfehler

Nein, gibts nicht. Der Compiler prüft sowas nicht. Das Ergebnis ist zwar nicht definiert, aber wird bei dieser Initialisierung bei wahrscheinlich allen Compilern in der Praxis 3 sein.

Ich wiederhole die wichtige Aussage:
Der Compiler überprüft NICHT die Arraygrenzen. Dafür ist der Programmierer immer selbst verantwortlich!

Der Compiler überprüft NICHT die Arraygrenzen. Dafür ist der Programmierer immer selbst verantwortlich!

Und um die Verantwortung abzugeben, kann man intelligente Arrays wie std::tr1::array verwenden. Im Debug-Modus werden Indizes geprüft, im Release hat man volle Geschwindigkeit wie bei rohen Arrays.

Pafi schrieb:

sooo. könnte stimmen zumindest gings auf^^

Ja auf, schon, aber nicht sortiert auf deins gibt nach Korrektur und Trenner einfügen das hier aus:
26,11,2,28,4,13,30,17,6,15,32,33,23,8,37,34,39,10,19,36,41,12,9,38,40,14,43,45,16,42,47,46,18,44,1,31,35,3,20,29,27,5,22,21,7,25,24,48 , meins aber 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, bei dir also den Array korrekt wiedergegeben, aber nicht sortiert wie oben gefordert

Und so gehts schneller

#include <iostream>
#include <algorithm>
int main(int argc, char *argv[])
{
    int arr [2][3][2][4][1] =
    {
        {{{{26},{11},{2},{28}},{{4},{13},{30},{17}}},{{{6},{15},{32},{33}},{{23},{8},{37},{34}}},{{{39},{10},{19},{36}},{{41},{12},{9},{38}}}},
        {{{{40},{14},{43},{45}},{{16},{42},{47},{46}}},{{{18},{44},{1},{31}},{{35},{3},{20},{29}}},{{{27},{5},{22},{21}},{{7},{25},{24},{48}}}}
    };
    std::cout << "DEINS:\n"
     << "," << arr[0][0][0][0][0] << "," << arr[0][0][0][1][0] << "," << arr[0][0][0][2][0] << "," << arr[0][0][0][3][0] << "," << arr[0][0][1][0][0] << "," << arr[0][0][1][1][0] << "," << arr[0][0][1][2][0] << "," << arr[0][0][1][3][0]
     << "," << arr[0][1][0][0][0] << "," << arr[0][1][0][1][0] << "," << arr[0][1][0][2][0] << "," << arr[0][1][0][3][0] << "," << arr[0][1][1][0][0] << "," << arr[0][1][1][1][0] << "," << arr[0][1][1][2][0] << "," << arr[0][1][1][3][0]
     << "," << arr[0][2][0][0][0] << "," << arr[0][2][0][1][0] << "," << arr[0][2][0][2][0]
     << "," << arr[0][2][0][3][0] << "," << arr[0][2][1][0][0] << "," << arr[0][2][1][1][0] << "," << arr[0][2][1][2][0] << "," << arr[0][2][1][3][0] << "," << arr[1][0][0][0][0] << "," << arr[1][0][0][1][0] << "," << arr[1][0][0][2][0]
     << "," << arr[1][0][0][3][0] << "," << arr[1][0][1][0][0] << "," << arr[1][0][1][1][0] << "," << arr[1][0][1][2][0] << "," << arr[1][0][1][3][0] << "," << arr[1][1][0][0][0] << "," << arr[1][1][0][1][0] << "," << arr[1][1][0][2][0]
     << "," << arr[1][1][0][3][0] << "," << arr[1][1][1][0][0] << "," << arr[1][1][1][1][0] << "," << arr[1][1][1][2][0] << "," << arr[1][1][1][3][0] << "," << arr[1][2][0][0][0] << "," << arr[1][2][0][1][0] << "," << arr[1][2][0][2][0]
     << "," << arr[1][2][0][3][0] << "," << arr[1][2][1][0][0] << "," << arr[1][2][1][1][0] << "," << arr[1][2][1][2][0] << "," << arr[1][2][1][3][0];

    std::cout << "\n\n";

    // geht genausogut so:
    for(int eins=0; eins<2;++eins)
        for(int zwei=0; zwei<3; ++zwei)
           for(int drei=0; drei<2; ++drei)
               for(int vier=0; vier<4; ++vier)
                   std::cout << "," << arr[eins][zwei][drei][vier][0] ;

    std::cout << "\n\n";

    std::cout << "Und sortiert gehts so:\n";

    // alle Zahlen aus dem multidimensionalen Array in einen Vector kopieren
    std::vector<int> vec(&arr[0][0][0][0][0],&arr[1][2][1][3][0]);
    // den mal sortieren (lassen)
    std::sort(vec.begin(),vec.end());
    // und alle Zahlen im Vektor ausgeben
    for(int i=0; i< vec.size(); ++i)
        std::cout << vec.at(i) << ", ";
}

Danke für den Hinweis bezgl. Arrays - ich benutze die nur noch so selten das mir das glatt durchging

Pafi schrieb:

sooo. könnte stimmen zumindest gings auf^^

Und so gehts schneller

#include <iostream>
#include <algorithm>
int main()
{
    int arr [2][3][2][4][1] =
    {
        {{{{26},{11},{2},{28}},{{4},{13},{30},{17}}},{{{6},{15},{32},{33}},{{23},{8},{37},{34}}},{{{39},{10},{19},{36}},{{41},{12},{9},{38}}}},
        {{{{40},{14},{43},{45}},{{16},{42},{47},{46}}},{{{18},{44},{1},{31}},{{35},{3},{20},{29}}},{{{27},{5},{22},{21}},{{7},{25},{24},{48}}}}
    };

    std::vector<int> vec(&arr[0][0][0][0][0],&arr[1][2][1][3][0]);
        std::sort(vec.begin(),vec.end());
        for(int i=0; i< vec.size(); ++i)
            std::cout << vec.at(i) << ", ";
}

so weit bin ich noch nicht^^
aber trotzdem nochmal danke für deine Hilfe