Hi

ich bin noch ziemlicher Anfänger, daher entschuldigt bitte wenn diese Frage eine offensichtlich dumme Frage ist, aber weder Forensuche noch google haben mir weiter geholfen.

Ich hab mein Problem mal auf das folgende sehr kleine Programm reduziert:
Quellcode:#include <iostream.h>


void ShowInts(const int &content)
{
    for(int i=0;i<3;i++)
    {
/* 8*/    cout << content[i] << " + " << content[i] << " = " << (content[i]+content[i]) << endl;
    };
};

int main()
{
    int list[3];
    list[0]=53;
    list[1]=12;
    list[2]=655;

/*19*/    ShowInts(list);
    return 0;
};

Dieses Programm funktioniert so nicht.
Die Funktion ShowInts(const int &content) soll eigendlich nur die Zahlen des übergebenen Arrays ausgeben (ohne es zu verändern). Aber sie denkt, sie bekäme nur einen integer als Parameter überliefert, und kann daher in der for-Schleife nichts mit dem []-Operator anfangen der ja für das Array gedacht ist. Daher bekomme ich in Zeile 8 (4mal) den Fehler:

Zitat:

"invalid types `const int[int]' for array subscript"

Zitat:

"invalid conversion from `int*' to `int' "
"initializing argument 1 of `void ShowInts(const int&)' "

Der Optimist glaubt, dass wir in der Besten aller Welten leben.
Der Pessimist fürchtet, dass dies stimmt.

Du musst ShowInts den Array als Pointer und nicht als Referenz übergeben. Also so:

Quellcode:#include <iostream.h>

void ShowInts(const int *content) // hier statt Referenz (&) eine Pointer (*)
{
    for(int i=0;i<3;i++)
    {
        cout << content[i] << " + " << content[i] << " = " << (content[i]+content[i]) << endl;
    };
};

int main()
{
    int list[3];
    list[0]=53;
    list[1]=12;
    list[2]=655;

    ShowInts(&list[0]); /* hier mit dem Refenrenzoperator (&)
                           den Pointer aud das erste Element
                           im Array übergeben */
    return 0;
}; Denn 'const int &content' ist nur _ein_ normaler int und der hat keinen Array-Opeartor: []

"Mit C++ (noch besser mit C) kann man sich _sehr_ leicht in den Fuss schiessen." - theDon
Auspack und freu! - Auszug aus einer, aus dem japanischen übersetzten, Bedienugsanleitung für ein Spielzeugaquarium.
--
Photon Audio Player | Majestic42.net | How To Ask Questions The Smart Way

wenn du nicht grade nen schreibkrampf willst dann kannst du auch das hier machen:
Quellcode:ShowInts(list);

Und idealerweise solltest du ShowInts() in einem zweiten Parameter die Groesse deines Arrays uebergeben, da das vermutlich nicht immer genau 3 sein wird. Wenn du das nicht machst, besteht die Gefahr, dass du ueber die Grenze hinaus liest (schreiben ist nicht, da das ja ein const int * ist). Da kommt aber mit ziemlicher Sicherheit Muell bei raus, das willst du nicht haben. ;)

\o tanz den naziprau! o/

And more than ever, I hope to never fall,
Where enough is not the same it was before

danke, die Lösung funktioniert einwandfrei!

Allerdings hat das einige andere Fragen aufgeworfen :)
1) Ich verstehe zwar, dass nur eine Adresse (des ersten Array-Slots) an die Funktion übergeben wird, aber ich verstehe nicht, woher die Funktion nun weiss, dass ihr eventuell auch ein Array übergeben werden könnte. Es könnte doch auch sein, dass sie wegen eines Fehlers des Programmierers einen int bekommt.
Dann wendet sie ja den []-Operator auf einen int an.

2) Ich habe testweise mal wirklich einen int übergeben. Bei content[0] hat er mir auch das richtige Ergebnis (den Wert des ints) angezeigt, bei den anderen beiden hat er mir zu meinem Erstaunen zwei zufällige Zahlen gezeigt (worauf theDon wohl auch hinaus wollte). Zwei zufällige Zahlen heisst, dass er von irgendwo etwas ausgelesen haben muss, also von irgendeinem Speicherplatz - was ja auch logisch klingt, der int hat keine sinnvollen Informationen an der Stelle, an der ein Array die Addresse des nächsten Elements trägt. Und was auch immer er da bei dem int vorgefunden hat, muss als Addresse verwendet ja irgendeinen Käse hervorgerufen haben.
Aber wieso gibt das (wenigstens zur Laufzeit) keinen Schutzfehler? Man kann doch nicht einfach von einer beliebigen Addresse etwas auslesen.
Ich hab gerade die ganze Zeit rumprobiert mit Arrays (Indizies mit höheren Werten als das Array Segmente hat), und ich konnte damit einfach Variablen auslesen die ich an anderer Stelle definiert hatte,[edit](jetzt klappts gerade nichtmehr)[/edit] und ich konnte sogar eine als const ausgezeichnete Variable ändern. Ok, war mist ^^ [edit³]ok, das const kann ich doch nicht umgehen[/edit³]

3) In Volkards Kurs steht, eine Referenz sei ein Zeiger, der so tut als sei er die Variable selbst.
Wieso zeigt dann die Referenz in meiner Version der Funktion nicht auch, wie das übergebene "list", einfach auf das erste Element des Arrays?
Also, wieso muss dass per Zeiger gelöst werden, und nicht per Referenz ?
Und angenommen, ich wollte ein Array unbedingt per call-by-value übergeben weil ich z.B. in der Funktion die Werte umändern muss, aber am Ende die Wertänderung nicht nach aussen hin sichtbar sein soll; wie müsste ich dann vorgehen?

Der Optimist glaubt, dass wir in der Besten aller Welten leben.
Der Pessimist fürchtet, dass dies stimmt.

1) Wenn du der Funktion nur einen int übergibst führt das zu einem Complierfehler:

Quellcode:[...]
int g = 0;
ShowInts(g);
[...]
=> error C2664: 'ShowInts' : Konvertierung des Parameters 1 von 'int' in 'const int *' nicht moeglich ...
2)

Zitat:

Ich habe testweise mal wirklich einen int übergeben

Das mit dem "über-das-Ende-hinaus-lesen" stimmt so und führen nicht zu einer Accessvialotion.

3)

Zitat:

Wieso zeigt dann die Referenz in meiner Version der Funktion nicht auch, wie das übergebene "list", einfach auf das erste Element des Arrays?

Zitat:

Und angenommen, ich wollte ein Array unbedingt per call-by-value übergeben weil ich z.B. in der Funktion die Werte umändern muss, aber am Ende die Wertänderung nicht nach aussen hin sichtbar sein soll; wie müsste ich dann vorgehen?

"Mit C++ (noch besser mit C) kann man sich _sehr_ leicht in den Fuss schiessen." - theDon
Auspack und freu! - Auszug aus einer, aus dem japanischen übersetzten, Bedienugsanleitung für ein Spielzeugaquarium.
--
Photon Audio Player | Majestic42.net | How To Ask Questions The Smart Way

1)
Ich meine sowas:

Quellcode:int JustOneInt=5;
ShowInts(&JustOneInt);
Damit arbeitet die Funktion mit dem selben Objekt wie es in der Hauptschleife deklariert wird, aber das ist ja dem Programm egal.
Worauf ich hinaus wollte war, dass er jetzt in der for-Schleife auf dieses Objekt, also auf einen ganz normalen integer, den []-Operator anwendet. Bei meinen vorherigen Tests hat er mir bei soetwas immer vorgeworfen, dass diese Operation nicht deklariert sei oder soetwas :/

2)
Find ich ganz schön gefährlich dass man einfach so Variablen auslesen und verändern kann. Dann kanns ja vorkommen, dass man den Wert einer Variablen ausversehen mit einem Array ändert und man sucht die ganze Zeit bei dieser Variablen nach dem Fehler und kann den nicht finden, weil nur durch einen dummen Zufall diese Variable auf dem Speicherplatz neben dem Array liegt und sonst kein Hinweis auf das Array da ist. Da muss man ja höllisch aufpassen :/

Kann man mit dem über-das-Ende-hinaus-lesen eigendlich auch Speicherplatz ändern, der eigendlich zu einem ganz anderen Programm gehört (z.B. zum Betriebssystem) ?

3)
Stimmt, das mit dem Vector ist eine gute Idee. danke

Der Optimist glaubt, dass wir in der Besten aller Welten leben.
Der Pessimist fürchtet, dass dies stimmt.

1) Wenn du das so machst dann ist der eine int für die Funktion 'ShowInts' wie ein Array mit einem Element, welcher dann natürlich den []-Operator hat.

2) Das ist so, C/C++ ist halt keine Sprache wie Java oder C#, wo das nicht geht.

Zitat:

Kann man mit dem über-das-Ende-hinaus-lesen eigendlich auch Speicherplatz ändern, der eigendlich zu einem ganz anderen Programm gehört (z.B. zum Betriebssystem) ?

"Mit C++ (noch besser mit C) kann man sich _sehr_ leicht in den Fuss schiessen." - theDon
Auspack und freu! - Auszug aus einer, aus dem japanischen übersetzten, Bedienugsanleitung für ein Spielzeugaquarium.
--
Photon Audio Player | Majestic42.net | How To Ask Questions The Smart Way

1)
aaah, dann ist also _jeder_ Zeiger ein Array mit mindestens einem Element?
Also ist *pZahl nur eine andere Schreibweise für pZahl[0] ?
Zumindest ergeben das meine 'Tests'.

Mhm, der Groschen fällt in Zeitlupe, aber irgendwann kommt er unten an ^^

2)
Achso. Wo kamen denn die Werte der Zufallszahlen her? Wurden die Bits einfach von dem Programm, dass vorher diesen Speicherplatz verwendet hat, übernommen?
Also hab ich eine Zahl in meinem Programm, die vielleicht ein anderes Programm zuvor verwendet hat? Oder meinetwegen auch 4 chars (8Bit) die nun meine 32 Bit des Integers sind ?

Der Optimist glaubt, dass wir in der Besten aller Welten leben.
Der Pessimist fürchtet, dass dies stimmt.

1) Nicht ganz. Ein Array kann mit einem Zeiger auf sein erstes Element übergeben werden, aber natürlich auch einzelne Werte. Es musst nicht ein Array hinter einere Addresse stehen. Ein Zeiger kann auch irgendwo hinzeigen, wenn man nicht aufpasst, also weder auf eine einzige Variable noch ein Array.
Das mit der Schreibtweise stimmt, noch klarer wirds wenn dus dir so vorstellst:
array[n] = *(array + n)
D.h. jedes Element kann auch durch Zeigerarithmetik dereferenziert werden.
2) Für gewöhnlich ist das so, ja.

Naja Onkelchen: Arrays sind halt einfach Zeiger, es gibt nur einige vereinfachte Schreibformen:

array[n] = *(array + n) // s.o.
pointer->foo = (* pointer).foo
array[n].peter = (array + n)->peter

edit: Wo bleibt eigentlich CN? :D

mwcollect - mein Projekt | oxlog - mein blog | happyhardcore.com Stream - gute Musik

Zitat:

Onkel Dittmeyer postete
array[n] = *(array + n)

ne, 0xFF hat schon recht

( www.opera.com | www.miranda-im.org )
http://www.ironoak.de

0xff da bin ich, normale menschen haben schule >:P oder arbeiten oder so

Zitat:

Aber wieso gibt das (wenigstens zur Laufzeit) keinen Schutzfehler? Man kann doch nicht einfach von einer beliebigen Addresse etwas auslesen.
Ich hab gerade die ganze Zeit rumprobiert mit Arrays (Indizies mit höheren Werten als das Array Segmente hat), und ich konnte damit einfach Variablen auslesen die ich an anderer Stelle definiert hatte,[edit](jetzt klappts gerade nichtmehr)[/edit] und ich konnte sogar eine als const ausgezeichnete Variable ändern. Ok, war mist ^^ [edit³]ok, das const kann ich doch nicht umgehen[/edit³]

Zitat:

Weil 'const int &content' ein int ist, also ein 'Objekt' und kein Pointer. Das & sorgt dafür das der int mit Call-By-Reference übergeben wird und deshalb Änderungen die die Funktion an ihm macht auch noch ausserhalb bestehen beiben.

achja das [pass by const reference] hat übrigens den vorteil das bei grossen objekten nicht erst ne kopie erstellt werden muss die an die funktion übergeben wird, ändern kann man das objekt ja dann trotzdem nicht
http://www.gotw.ca/gotw/006.htm

Zitat:

Da muss man ja höllisch aufpassen :/

superhausi
ne das is zeigerarithmetik

@Superhausi, das war auch nur auf diesen Fall bezogen und da wars ein int, was genauso groß ist wie ein *int.
Aber eigentlich hast du natürlich Recht.

onkel
ich hätte gerne mal erklärt wieso er "eigentlich natürlich recht hat" und was das mit int zu tun hat

Zitat:

CN postete
onkel
ich hätte gerne mal erklärt wieso er "eigentlich natürlich recht hat" und was das mit int zu tun hat

Nehmen wir an, wir hätten ein int[3] an der Position 0 (zum vereinfachen). Der erste liegt also bei 0, der zweite bei 4 und der dritte bei 8, da ja ein int auf einem 32-Bit System 4 Byte hat. my_int_array[0] greift jetzt also auf 0, my_int_array[2] auf 8 und nicht auf 2 zu. Also my_int_array + 2 * 4.
Entweder ich stehe jetzt komplett auf der Leitung oder aber du hast irgendwo etwas falsch verstanden... Könnte mal sonst noch jemand seine Meinung dazu abgeben?

Es ist dabei natürlich zu beachten, dass wir von einem int * und nicht void * oder byte * ausgehen...

Also...

Das was da in CN's Link zu Zeigerarithmetik steht ist richtig.

Superhausi, du liegst falsch, ein Pointer auf eine int (4 Byte bei 32-Bit gross) kann nicht in Byte-Schritten bewegt werden, dazu müsste man ihn in eine Byte/Char casten. Fazit: ein Pointer kann immer nur Vielfache der Grösse seines Typs annehmen.

Hier ein Beispiel mit int:
Quellcode:#include <iostream>

using namespace std;

int main(int argc, char* argv[])
{
    int  array[5];
    int* pointer = array;

    memset(array, 0, sizeof(int) * 5);

    // pointer wird durch ++ um sizeof(int) = 4 byte erhöht
    // bevor er dereferrenziert wird und die Zuweisung stattfindet
    *  pointer = 42; // pointer = <base> +  0 byte
    *++pointer = 52; // pointer = <base> +  4 byte
    *++pointer = 62; // pointer = <base> +  8 byte
    *++pointer = 72; // pointer = <base> + 12 byte
    *++pointer = 82; // pointer = <base> + 16 byte

    for(int i = 0; i < 5; i++)
        cout << array[i] << " ";

    return 0;
}
Ausgabe:
Quellcode:42 52 62 72 82
Hier ein Beispiel mit char:
Quellcode:#include <iostream>

using namespace std;

int main(int argc, char* argv[])
{
    char  array[5];
    char* pointer = array;

    memset(array, 0, sizeof(char) * 5);

    // pointer wird durch ++ um sizeof(char) = 1 byte erhöht
    // bevor er dereferrenziert wird und die Zuweisung stattfindet
    *  pointer = 'A'; // pointer = <base> + 0 byte
    *++pointer = 'C'; // pointer = <base> + 1 byte
    *++pointer = 'B'; // pointer = <base> + 2 byte
    *++pointer = 'D'; // pointer = <base> + 3 byte
    *++pointer = 'E'; // pointer = <base> + 4 byte

    for(int i = 0; i < 5; i++)
        cout << array[i] << " ";

    return 0;
}
Ausgabe:
Quellcode:A B C D E


"Mit C++ (noch besser mit C) kann man sich _sehr_ leicht in den Fuss schiessen." - theDon
Auspack und freu! - Auszug aus einer, aus dem japanischen übersetzten, Bedienugsanleitung für ein Spielzeugaquarium.
--
Photon Audio Player | Majestic42.net | How To Ask Questions The Smart Way

Zitat:

HammerBlade postete
1) Wenn du das so machst dann ist der eine int für die Funktion 'ShowInts' wie ein Array mit einem Element, welcher dann natürlich den []-Operator hat.

Daraus ergibt sich ein recht kranker Zusammenhang:
Quellcode:int foo[42];
// die Folgenden Zeilen sind aequivalent.
foo[23] = 1337;
*(foo + 23)  = 1337;
*(23 + foo) = 1337;
23[foo] = 1337;

\o tanz den naziprau! o/

And more than ever, I hope to never fall,
Where enough is not the same it was before

Zitat:

HammerBlade postete
Also...

Das was da in CN's Link zu Zeigerarithmetik steht ist richtig.

Superhausi, du liegst falsch, ein Pointer auf eine int (4 Byte bei 32-Bit gross) kann nicht in Byte-Schritten bewegt werden, dazu müsste man ihn in eine Byte/Char casten. Fazit: ein Pointer kann immer nur Vielfache der Grösse seines Typs annehmen.
<snip>

Zitat:

my_int_array[0] greift jetzt also auf 0, my_int_array[2] auf 8 und nicht auf 2 zu.

Ich hab dich irgendwie vorher nicht richtig verstanden. Lag wohl daran, dass bei dir jegliche Einheit fehlt und so daran herum interpertiert weden kann.

Quellcode:int array[...];

array[n] = *(array + n * sizeof(*array));
Wenn man das als C/C++ Code interpertier ist es falsch. Mathematisch soll es wohl das richtige darstellen, ist aber sehr missverständlich, da man z.B. mit n=1 (wobei hier eine 1 bei der Pointeraddition 4 byte entspricht, also Faktor 4) nicht auf '<base> + 1 * 4 byte' zugreifen würde, sondern auf '<base> + 1 * 4 byte * 4 byte' also '<base> + 16 byte' zugreift.

Hättest du hier ein paar Einheiten eingestreut wäre es (für mich) wesentlich klarer gewesen:

Zitat:

Superhausi postet
my_int_array[0] greift jetzt also auf 0, my_int_array[2] auf 8 und nicht auf 2 zu.

"Mit C++ (noch besser mit C) kann man sich _sehr_ leicht in den Fuss schiessen." - theDon
Auspack und freu! - Auszug aus einer, aus dem japanischen übersetzten, Bedienugsanleitung für ein Spielzeugaquarium.
--
Photon Audio Player | Majestic42.net | How To Ask Questions The Smart Way

Ok, dann ist ja alles klar... Hab wohl einfach zu lange keinen C-Code mehr geschrieben... Aber irgendwie bin ich froh, dass ich nicht alles was C/C++ angeht vergessen habe in den Jahren...

eine Frage hätte ich noch (zwar ganz unabhängig vom Threadtitel, aber die ist mir eingefallen als ich das von euch hier gelesen habe):
Wozu ist der Datentyp bool gut?
Laut http://www.hp-gramatke.de/primes/german/page0030.htm wird ein bool auch mit einem byte, also 8 Bits, gespeichert. Wo liegt dann der Vorteil gegenüber z.B. char (auch 1 Byte=8Bit )?

Und stimmt es, dass man noch besser einen int (32Bit=4Byte) benutzten soll, selbst wenn man wirklich nur 2 Zustände haben wird, weil die Rechner alle auf 32Bit getrimmt sind ?
[edit] Ich meine, es stimmt zwar schon dass die Recher auf 32 Bit ausgelegt sind, aber macht diese Optimierung wirklich das Mehr an Speicherplatz und die 4fache Menge an Bits (die bei jeder Prüfung eingelesen und verglichen werden müssen) wieder wett ?

Der Optimist glaubt, dass wir in der Besten aller Welten leben.
Der Pessimist fürchtet, dass dies stimmt.

Zitat:

Und stimmt es, dass man noch besser einen int (32Bit=4Byte) benutzten soll, selbst wenn man wirklich nur 2 Zustände haben wird, weil die Rechner alle auf 32Bit getrimmt sind ?

"selbermachen rockt am meisten :D" - -LeJean-

Der Datentyp `bool' ist fuer Wahrheitswerte gedacht.
Man verwendet den zum Beispiel, weil `bool foo()' aussagekraeftiger ist als 'int foo()'.

Wie viel Speicher der intern belegt, kann (und sollte) dir erstmal voellig egal sein.

Und nein, man nimmt nicht besser einen Int. Ein guter Compiler erzeugt Code, der das Alignment beruecksichtigt, dh. er baut Platzhalter zwischen die einzelnen Speicherplaetze.

Wenn man ganz viele bools auf einmal zu vermalten hat, nimmt man am besten std::bitvector (bzw. std::vector<bool>, das ist aequivalent). Dann werden intern Bitfelder benutzt, platzsparender geht es also nicht mehr.

\o tanz den naziprau! o/

And more than ever, I hope to never fall,
Where enough is not the same it was before