Problem mit Feldern

Vertexwahn

cout << "Wie gross soll das Array werden? "; 
int size; 
cin >> size; 
int foo[size];

Wie war das gleich noch mal - Arrays müssen eine konstante Größe haben? obiger Programmcode funktioniert nicht - such dir mal Informationen zum Thema dynamische Speicherreservierung

Vertexwahn

#include <iostream>
using namespace std;

int main()
{
	cout<<"Wie gross soll das Array werden? "; 

	int Summe = 0;

	int ArraySize  = 0;
    cin>>ArraySize;
    int* Array = new int[ArraySize];

	for(int i = 0; i < ArraySize; i++)
	{
		cout<<"Geben Sie das "<<i+1<<"te"<<" Element ein: ";
		cin>>Array[i];

		Summe = Summe + Array[i];
	}

	cout<<"Die Summe ist: "<<Summe<<endl;

	delete[] Array;
}

http://tutorial.schornboeck.net/dyn_speicher.htm

Vertexwahn

Alternativ mit schafen s

#include <iostream>
using namespace std;

namespace Umlaut
{
   const unsigned char AE = static_cast<unsigned char>(142);
   const unsigned char ae = static_cast<unsigned char>(132);
   const unsigned char OE = static_cast<unsigned char>(153);
   const unsigned char oe = static_cast<unsigned char>(148);
   const unsigned char UE = static_cast<unsigned char>(154);
   const unsigned char ue = static_cast<unsigned char>(129);
   const unsigned char ss = static_cast<unsigned char>(225);
}

int main()
{
	cout<<"Wie gro"<<Umlaut::ss<<" soll das Array werden? "; 

	int Summe = 0;

	int ArraySize  = 0;
    cin>>ArraySize;
    int* Array = new int[ArraySize];

	for(int i = 0; i < ArraySize; i++)
	{
		cout<<"Geben Sie das "<<i+1<<"te"<<" Element ein: ";
		cin>>Array[i];

		Summe = Summe + Array[i];
	}

	cout<<"Die Summe ist: "<<Summe<<endl;

	delete[] Array;
}

evilissimo

@Vertexwahn

namespace Umlaut
{
   const unsigned char AE = static_cast<unsigned char>(142);
   const unsigned char ae = static_cast<unsigned char>(132);
   const unsigned char OE = static_cast<unsigned char>(153);
   const unsigned char oe = static_cast<unsigned char>(148);
   const unsigned char UE = static_cast<unsigned char>(154);
   const unsigned char ue = static_cast<unsigned char>(129);
   const unsigned char ss = static_cast<unsigned char>(225);
}

was zum Teufel hat das denn für einen Sinn?

//Edit: um hier net nen falschen eindruck zu vermitteln und mir hier jemand versucht zu erklären was das bedeutet.

Warum nicht so?

namespace Umlaut
{
   const unsigned char AE = 142;
   const unsigned char ae = 132;
   const unsigned char OE = 153;
   const unsigned char oe = 148;
   const unsigned char UE = 154;
   const unsigned char ue = 129;
   const unsigned char ss = 225;
}

Muss man das verstehen warum man sich so nen schreib aufwand macht?

Vertexwahn

> was zum Teufel hat das denn für einen Sinn?

1. Ausrede:
Ich benutze eine MS Compiler – da wird man mit der Zeit misstrauisch

2. Ausrede:
manchmal wenn etwas funktioniert freut man sich einfach und denkt nicht mehr darüber nach

du hast recht - macht keinen Sinn das casten

enno-tyrant

es kam mir doch gleich do bekannt vor: deutsche umlaute

Cheffe

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

net 0

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

Vertexwahn

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

ändert aber nichts daran, dass das casten unsinnig ist

enno-tyrant

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

Power Off

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!

enno-tyrant

wirklich gute erklärung ,

eine anmerkung, statt

int* v = new char [ 10 ];

muß es:

int* v = new int [ 10 ];

heißen.

Michael E.

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.

Cheffe

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

enno-tyrant

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)

Cheffe

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

enno-tyrant

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

Caipi

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

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.

Du erstellst den String.
Du uebrgibst den string via function(std::string a);
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

Power Off

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!