3. Problem mit Feldern

Problem mit Feldern

  • E

    es kam mir doch gleich do bekannt vor: deutsche umlaute

    0
  • C

    Hi!

    Vielen dank für die vielen Antworten 🙂 das ging jo schnell...
    ich habs jetzt endlich geschafft 🙂 komischerweise kann ich die größe des Felds mit einer Variablen bestimmen 😕

    hier mein fertiger code:

    #include <iostream>
using namespace std;

int Feldzahl;
int Feldfunktion(int a);
int *Feld;
int Summe = 0;
int main(void)
{
    cout <<"Wieviele Zahlen möchten zie addieren?: ";
    cin >> Feldzahl;
    int Feld[Feldzahl];
    for(int i = 0; i < Feldzahl; i++)
    {
        cout << "\nBitte geben sie eine Zahl ein: ";
        cin >> Feld[i];
        Summe += Feld[i];
    }

    cout << "\nDas Ergebniss lautet:" << Summe;

    cin >> Summe;
    return 0;
}

    ich benutze den Compiler Dev-C++... kanns sein das er das mit der dynamischen speicherreservierung automatisch macht??? kann mir das ned anders erklären...

    naja auf jeden fall funktioniert das programm wunderbar 🙂

    danke für die hilfe

    mfg Cheffe

    0
  • N

    Cheffe schrieb:

    ich benutze den Compiler Dev-C++... kanns sein das er das mit der dynamischen speicherreservierung automatisch macht??? kann mir das ned anders erklären...

    sollte eigentlich nicht gehen. ist das eine gcc-spezifische erweiterung (heimliches malloc oder wie 😃 )? probier's mal mit -Wall -ansi -pedantic

    0
  • V

    > es kam mir doch gleich do bekannt vor: deutsche umlaute

    ändert aber nichts daran, dass das casten unsinnig ist

    0
  • E

    Vertexwahn schrieb:

    ändert aber nichts daran, dass das casten unsinnig ist

    korrekt

    kaum zu glauben mit dem 'gcc 3.4.2' compiler bekomme ich den code auch compiliert, mhh eigenartig

    //edit üblige schreibfehler

    0
  • P

    Cheffe schrieb:

    aber jetzt gehts in dem Tut mit feldern los und das find ich extrem verwirrend 😞 ich habs mir tausend mal durchgelesen und dann versucht die Programmaufgaben dazu zu schreiben, aber ich schaffs ned 😞 ich hab mir ewig darüber den Kopf zerbrochen und jetzt bin ich an dem Punkt angelangt wo ich nach Hilfe frag ^^

    Besorg Dir mal "Das C Lernbuch" von Thomas Plum, da ist die beste Erklaerung fuer Felder drin, die ich je gelesen habe.

    Im Prinzip kannst Du Dir Felder wie eine Reihe von Schachteln vorstellen, die von links nach rechts durchnummeriert sind. In jede Schachtel kannst Du etwas hineintun.

    z.B.:

    int feld[3];

    waeren drei Schachteln, durchnummeriert von 0 bis 2 (in C/C++ werden Felder immer von 0 ab nummeriert), in die Du jeweils eine Ganzzahl (int) legen kannst.
    Also z.B.:

    feld[0] = 100;
feld[1] = 200;
feld[2] = 300;

    Jetzt ist es so, dass der Speicher Deines Computers auch ein grosses Feld ist. D.h. wenn du einen Computer mit 512 MB Speicher hast, dann wuerde das in C/C++ so aussehen:

    char Computerspeicher[536870912]; /* 512 MB */

    Jede Variable, die Du deklarierst, jede Funktion die Du schreibst, belegt Speicher in Deinem Computer. Wenn Dein Programm geladen wird, wird es Byte fuer Byte in jeweils eine Schachtel des Computerspeichers gelegt. Die Nummern des Computerspeichers werden auch Adressen genannt. Eine Variable, die eine Adresse enthaelt, nennt man Zeiger.

    Einen Zeiger koennte man so schreiben:

    int zeiger = 1024;                /* 1024 waere die Adresse */
Computerspeicher[zeiger] = 'A';   /* A wuerde in Schachtel 1024 geschrieben */

    Jedoch hat die Sprache C/C++ eine besondere Konstruktion fuer Zeiger:

    int a = 5;   /* Ganzzahl-Variable "a" hat den Wert 5 */
int* z = &a; /* "&a" bedeutet "Adresse von a", 
             *  "int*" bedeutet "Zeiger auf Ganzzahl",
             *  also ist "z" eine Zeigervariable auf Ganzzahlen, die
             *  mit der Adresse von "a" initialisiert wird.
             */
*z = 7;      /* "*z" bedeutet "die Ganzzahl, auf die z zeigt",
             *  also wird 7 in die "Ganzzahl, auf die z zeigt" geschrieben.
             *  Dadurch aendert sich der Wert der Variable "a" von 5 nach 7.
             */
int* v = new int [ 10 ];  /* weist "v" 10 neue Ganzzahl-Schachteln aus dem
                          *  Computerspeicher zu. D.h. "v" zeigt auf den
                          *  Beginn der Schachteln.
                          */
v[0] = 3;    /* Schreibt "3" in die 0-te Schachtel */
delete [] v;  /* gibt die Schachteln des Computerspeichers, auf die
              *  "v" zeigt, wieder fuer andere Benutzer frei.
              */

    Ich hoffe, das hilft Dir etwas! 🙂

    0
  • E

    wirklich gute erklärung 👍 ,

    eine anmerkung, statt

    int* v = new char [ 10 ];

    muß es:

    int* v = new int [ 10 ];

    heißen. 😃

    0
  • M

    YASC schrieb:

    Michael E. schrieb:

    Felder (oder englisch Arrays) sind nützlich, wenn du viele

    string monate[12];
monate[1] =  "Januar";
monate[2] =  "Februar";
/* etc. */

    string monate[12];
monate[0] =  "Januar"; // <-- Bitte so
monate[1] =  "Februar"; // <-- Bitte so
/* etc. */

    Der Array fängt ja schließlich mit 0 an.

    Oh mein Gott! Ich fass es nicht 😮

    Ich glaub, ich muss ins Bett.

    0
  • C

    Power Off schrieb:

    Ich hoffe, das hilft Dir etwas!

    worauf du dich verlassen kannst 🙂 die erklärung is echt super vielen dank 🙂 jetzt verstehe ich auch zeiger etwas besser obwohl mir die noch immer en bissl schleierhaft sind... verstehe ned so richtig was die bringen...

    mfg Cheffe

    0
  • E

    Cheffe schrieb:

    ...jetzt verstehe ich auch zeiger etwas besser obwohl mir die noch immer en bissl schleierhaft sind... verstehe ned so richtig was die bringen...

    mit zeigern bearbeitest du die z.b. variablen direkt und keine kopien von denen (spart u.u. rechenzeit)

    0
  • C

    aber ich kann die variablen auch gleich direkt bearbeiten oder??
    zB a=5 und nicht *Zeigeraufa=5... wo is da der unterschied? und was bringts mir Zeigeraufa zu nutzen?

    mfg Cheffe

    0
  • E

    wenn du variablen an funktionen übergibst, übergibst du nur kopien der variablen. übergibst du zeiger aud die adressen der variablen müssen keine kopien erzeugt werden

    0
  • C

    Cheffe schrieb:

    aber ich kann die variablen auch gleich direkt bearbeiten oder??
    zB a=5 und nicht *Zeigeraufa=5... wo is da der unterschied? und was bringts mir Zeigeraufa zu nutzen?

    mfg Cheffe

    Vielleicht hier eine kleine, ergänzende Einführung über Parameterübergabe by Value, by Reference etc.

    Caipi

    0
  • ?

    Jetzt noch mein Senf...

    by Reference

    Wir nehmen an du willst eine Function haben, welche dir irgend was macht.
    du uebergibst einen grossen String.
    Er wird in der function ausgelesen, und dann wieder zurueckgegeben.

    1. Du erstellst den String.
    2. Du uebrgibst den string via function(std::string a);
    3. Du gibst ihn zurueck.

    So hast du den String 2mal b.z.w. 3mal erstellt.
    Bei einem grossen String brauchst du megaviel RAM.

    Wenn du aber die uebergabe via Reference machst hast du den string nur einmal.
    und du kannst ihn "scharf" bearbeiten, also nicht die Kopie.

    wie nun "by Reference"

    ganz einfach:

    int b(std::string &a){
     a+="bla";
     return 1;
}

    so kannst du bei grossen projekten, und zu besten des "sauberen" codes, arbeiten.

    MFG Ghost

    0
  • P

    enno-tyrant schrieb:

    wirklich gute erklärung 👍 ,

    eine anmerkung, statt

    int* v = new char [ 10 ];

    muß es:

    int* v = new int [ 10 ];

    heißen. 😃

    Danke!! Ich hab's entsprechend abgeaendert! 🙂

    0
  • P

    Cheffe schrieb:

    aber ich kann die variablen auch gleich direkt bearbeiten oder??
    zB a=5 und nicht *Zeigeraufa=5... wo is da der unterschied? und was bringts mir Zeigeraufa zu nutzen?

    mfg Cheffe

    Klar kannst Du die Variable auch direkt aendern.

    Zeiger verwendet man immer dort, wo man gerne einen Zeiger auf Daten haben moechte. Z.B. wie bereits von enno-tyrant beschrieben, bei der Parameteruebergabe an Funktionen. Aber auch, wenn man Datenstrukturen hat, bei denen man keine Datenverdoppelung moechte. Oder wenn man mehrere Datenstrukturen miteinander verbinden will.

    struct Auto {
   string   marke;
   string   modell;
   Rad*     raeder[4];   // vier Zeiger, die jeweils auf ein Rad zeigen.
};
struct Reifen {
   string   marke;
   string   modell;
   int      groesse;
};
struct Felge {
   string   marke;
   string   modell;
};
struct Rad {
   Reifen*  bereifung;  // zeigt auf einen Reifen
   Felge*   felge;      // zeigt auf eine Felge
};

    Was man noch bedenken muss, ist, dass Zeiger im Prinzip auch nur Variable sind, die einen Wert haben muessen, bevor sie verwendet werden. Ein typischer Anfaenger-Fehler, der meist zu einem Absturz fuehrt, ist:

    int* v;
*v = 5;

    Obwohl das Ganze harmlos aussieht, ist es ein Programmfehler. Denn dem Zeiger "v" wurde noch keine Adresse zugewiesen. Solche Variable nennt man uninitialisiert, sie koennen jeden beliebigen zufaelligen Wert enthalten, der gerade in der Speicherzelle steht, die die Variable gerade belegt.

    In C++ hat man versucht, das Problem zu minimieren, indem man Referenzen eingefuehrt hat. Eine Referenz ist ein Zeiger, der immer initialisiert sein muss, und der immer auf eine bestimmte Adresse zeigt.

    int a;
int& r = a;  // "r" ist eine Referenz auf eine Ganzzahl, 
             // die "a" referenzieren soll.
r = 5;       // aendert den Wert von "a" in 5, da "r" eine Referenz auf "a" ist.
    0
  • C

    Hi!

    Erstmal vielen dank für die ganzen erklärungen 👍 das hat mir Zeiger wirklich näher gebracht... 🙂 (obwohl ich se immer noch unheimlich finde^^)

    jetzt noch ne frage (is halt en bissl offtopic): ich suche schon die ganze zeit irgendwelche Aufgabenstellungen für programme um C++ etwas üben zu können... mir fallen leider keine ein 😞
    kennt ihr villeicht irgendwelche Seiten zu dem Thema? lösungen wären nicht schlecht müssen aber nit sen...
    Oder villeicht irgendwas anderes... bin für alles dankbar 🙂

    mfg Cheffe

    0
  • L

    also ich mach das so das ich mir eigenen problemstellungen gebe

    zb addiere 2 zahlen oder subtrahieren

    oder schau nach algorithmen zur primzahlzerlegung oder pruefung usw

    das kann man von anfang an, doch mit vorranschreitendem wissen verfeinert man das ganze (zb so dass man zeiger uebergibt um die zahlen nur einmal erzeugen zu muessen)

    zb auf beliebig grosse zahlen da kommen dann solche sachen wie dynamische arrays

    ,wie man sie in vb nennt und in c eigentlich mit verketteten listen realisiert,

    mit rein

    ich wuerde da mit kleinen sachen anfangen und zur pruefung ob du richtig liegst brauchste ja nur dein ergebnis ueberpruefen 😉

    0
  • C

    Hi!

    naja mit solchen Aufgaben hab ichs auch scho probiert... aber langsam gehn mir die ideen aus 😞 naja ich hab mir daweil die Aufgabe gestellt ein Schiffe versenken zu programieren... was bei meinen Programmierkenntnissen ganz schön schwer is... leider kann ich noch ned irgendwie grafisch programmieren also muss halt ein 2D Array her...
    mal sehn ob was draus wird 🙂

    mfg Cheffe

    0
  • C
    Mod

    Power Off schrieb:

    In C++ hat man versucht, das Problem zu minimieren, indem man Referenzen eingefuehrt hat. Eine Referenz ist ein Zeiger, der immer initialisiert sein muss, und der immer auf eine bestimmte Adresse zeigt.

    eine referenz kann durch pointer implementiert sein, sie ist aber keiner. und es gibt objekte, die keine adresse haben (z.b. registervariablen) - einen pointer darauf kann man nicht erstellen (was dazu führt, dass das betreffende objekt im speicher angelegt werden muss, wenn man bezug auf seine adresse nimmt), eine referenz dagegen schon.

    0
Anmelden zum Antworten