3. Sind array's ueberfluessig?

Sind array's ueberfluessig?

  • O

    ok, dann nehm ich alles(was char betrifft) zurück

    0
  • K

    Raptor schrieb:

    Man kann ja folgendes

    char arr={"hallo"};

    ja ganz einfach durch

    char* ptr={"hallo"};

    ersetzen.

    Es würde mich wundern, wenn das erste keinen Compilerfehler hervorrufen würde, denn ein char ist nunmal nur ein Zeichen! Für Strings nimmt man für gewöhnlich std::string!

    0
  • H

    Nein sind Sie nicht. Du meinst sowas:

    int * foo;

foo[0] = 55;
foo[1000] = 56;

    Lässt sich ja problemlos compilieren. Ist aber undefiniertes Verhalten. Du überschreibst Speicher, der dir nicht gehört. Damit kannst du ernsthaften Schaden anrichten.

    0
  • R

    Sind arrays ueberfluessig, wenn ich doch alles ueber Zeiger regeln kann?

    Prinzipiell eigentlich schon ! 🙂
    Im Speicher ist nen Array nix anders als nen allocierter Speicher. Man koennte alles ueber dynamischen Speicher machen

    In der Praxis gibts 2 unterschiede.

    Die groesse eines (definierten) arrays ist zur compilezeit bekannt ! Das heisst das Teil kann statisch sein, also komplett aufm Stack liegen (Geschwindigkeit beim erzeugen / allocieren !!! ). Versuch das mal mit dynamischen Speicher. So ohne weiteres wirst doch da schwer tun 🙂

    Der Index wird vom compiler aufgeloest ... erspart ne menge rumeierei / lokale zeige um die richtige addresse im array zu bekommen. Ist eben einfach und bequem und vor allem schnell.

    Ciao ...

    0
  • G

    otze schrieb:

    string literale sind doch nur temporäre objekte...

    Richtig, sie sind temporär. Sie existieren nur solange, solange das Programm läuft. 😃

    buhl schrieb:

    Wir haben 'ne nette Zeichenkette im Uralt-Stil:

    char Name[80];

    Toll. Was tun, wenn Nme länger als 80 Zeichen???

    Hier bekommst du uU schon Probleme, wenn Name genau 80 Zeichen lang ist.

    Raptor schrieb:

    Also, sind array's ueberfluessig?

    Ich denke nicht. Egal ob du statisch oder dynamisch Speicher reservierst, du brauchst einen Arraytyp:

    int foo1[100];
int* foo2 = new int[100];
    0
  • H

    Ich revidiere meine letzte Aussage. Natürlich sind Arrays überflüssig. Man kann sie prinzipiell durch verkettete Listen ersetzen.

    0
  • S

    Helium schrieb:

    Ich revidiere meine letzte Aussage. Natürlich sind Arrays überflüssig. Man kann sie prinzipiell durch verkettete Listen ersetzen.

    bei dir als D Anhänger hätte ich eher auf ein "Natürlich sind alle Datenstrukturen überflüssig, man kann ja überall dynamische Arrays verwenden" getippt :p

    🤡

    0
  • K

    Wenn Du C++ programmierst, nimm für String den std::string

    #include <string>

    std::string beliebigLangerName = "Kartoffelsack";

    Und für andere Fälle std::vector

    #include <vector>

    std::vector<int> zahlen;

    zahlen.push_back(1);
    zahlen.push_back(2);

    cout << zahlen[0]; //gibt '1' aus

    Beschäftige Dich mit den Arrays und den char*-Zeichenketten nur, wenn:
    1. Du C programmieren willst und nicht C++
    2. Wenn Du eine Bibliothe mit C-Schnittstelle ansprechen musst
    3. Wenn Du Dich explizit damit beschäftigen willst (was man machen sollte, nur entnehme ich Deiner Frage, dass Du erst noch andere Sachen lernen solltest 🙂 )

    0
  • C

    Hier bekommst du uU schon Probleme, wenn Name genau 80 Zeichen lang ist.

    Öhm das stimmt IMO nicht. Das Array beginnt ja bei 0 und hört bei 79 auf = 80 Zeichen 🙂

    int * foo;

foo[0] = 55;
foo[1000] = 56;

    Warum überschreibt man hier "verbotenen" Speicher? Weil man auch foo[1-999] auch überschreibt oder wie? 😕

    0
  • S

    CorDharel schrieb:

    Hier bekommst du uU schon Probleme, wenn Name genau 80 Zeichen lang ist.

    Öhm das stimmt IMO nicht. Das Array beginnt ja bei 0 und hört bei 79 auf = 80 Zeichen 🙂

    und wo speicherst du das 0 zeichen?

    0
  • B

    CorDharel schrieb:

    int * foo;

foo[0] = 55;
foo[1000] = 56;

    Warum überschreibt man hier "verbotenen" Speicher? Weil man auch foo[1-999] auch überschreibt oder wie? 😕

    Probier mal folgendes aus:

    int main() {
  int x;
  cout << x << endl;
}

    Welche Zahl kommt raus? Keine Ahnung, aber du kannst es nicht beeinflussen ... das ist halt der "Müll", der an der Stelle zufällig im Speicher steht. Genauso ist das bei deinem Pointer. Das wo er hinzeigt, kannst du nicht beeinflussen -- oder besser gesagt, du hast es nicht beeinflusst. Er könnte ausserhalb deines Adressraumes zeigen (-> Sofortabsturz bei foo[0]), er könnte auf Nur-Lese-Speicher zeigen, er könnte auf andere existierende Variablen zeigen (du würdest diese dann überschreiben und dich wundern was da los ist). Oder auch rein zufällig auf freien Speicher. Mit den Worten des C++-Standards: Undefiniertes Verhalten. Wenn du gern Russisches Roulette spielst, kannst du an der Stelle aufhören zu lesen. Ansonsten solltest du zusehen, dass der Zeiger auf einen ausreichend großen Speicherbereich zeigt, in dem du arbeiten kannst und willst.

    0
  • O
     

    int * foo;

foo[0] = 55;
foo[1000] = 56;

    Warum überschreibt man hier "verbotenen" Speicher? Weil man auch foo[1-999] auch überschreibt oder wie? 😕

    ok, ganz kurz: du musst dem compiler sagen, dass er dir erstmal die 4000bytes platz beschaffen soll, das macht er nämlich nicht automatisch.
    das bedeuted, der speicher den du da unter dem pointer hast ist nicht besetzt, der compiler kann dort also belibige andere variablen unterbringen,was zur folge hat, dass du beim nächsten foo[99]=10 vielleicht eine oder mehrere andere variablen überschreibst, und das ist sehr schlecht 😉

    0
  • ?

    ok, ganz kurz: du musst dem compiler sagen, dass er dir erstmal die 4000bytes platz beschaffen soll

    nee du mußt ihm sagen, daß er platz für 1000 ints reservieren soll

    0
  • O

    was im fall eines 32bit systems und einem array 4000byte sind.

    0
  • C

    Und das reservieren von Speicher für einen Zeiger macht man mit

    char* ptr={"hallo"};

    😕

    0
  • O

    in dem fall schon.
    dann gibts noch:

    int foo[1000];//4000 byte aufm stack reservieren
int* bar=new int[1000];//4000 byte auf dem heap reservieren, delete nich vergessen
int* bar2=static_cast<int*>(malloc(4000));//umständliche version von new, muss mit free wieder freigegeben werden.

    mehr fällt mir im moment nich ein...

    0
  • W

    otze schrieb:

    ok, ganz kurz: du musst dem compiler sagen, dass er dir erstmal die 4000bytes platz beschaffen soll, das macht er nämlich nicht automatisch.

    Seit wann können Compiler Speicher anfordern?

    otze schrieb:

    int* bar2=static_cast<int*>(malloc(4000));//umständliche version von new, muss mit free wieder freigegeben werden.

    Mal ganz abgesehen davon, dass man den Rückgabewert von malloc nicht casten soll, und dass malloc in C++ Code nichts zu suchen hat ist es keine "umständliche Version von new" 🙄 .

    0
  • O

    In C++ muss man casten und deshalb ist malloc umständlicher als new. Aber verboten ist es nicht.

    0
  • ?

    man sollte doch besser sizeof(int)*arraysize schreiben

    0
  • W

    operator void schrieb:

    In C++ muss man casten und deshalb ist malloc umständlicher als new. Aber verboten ist es nicht.

    Nein, verboten ist es nicht. Aber es hat IMO trotzdem nichts in vernünftigem C++ Code zu suchen.

    0
Anmelden zum Antworten