Hallo,

ich hab ein Array mit Jahreszahlen, jetzt will ich in Array jz5, alle Jahre einfügen die mit 195x beginnen, den rest in Array jrest.

bei der ausgabe der jahre bei jz5 und jrest kommen diese zahlen und danach einfach beliebige zahlen - hängt davon, dann ich max. menge falsch definiert habe - aber ich weiß davor nicht, wieviel platz ich brauche.

wie kann ich es ändern dass bei der ausgabe nur die zahlen rauskommen die ich brauche?

danke

int iarr[]={1970, 1956, 1921, 1994, 1933, 1937, 

1945, 1940, 1928, 1972, 1976, 1944, 1992, 1914, 

1908, 1968, 1954, 1959, 1929, 1943, 1939, 1942,

1992, 1919, 1951, 1947, 1990, 1943, 1955, 1987,

1902, 1955, 1908, 1914, 1943, 1972, 1988, 1983,

1983, 1928, 1907, 1970, 1942, 1923, 1990, 1935,

1958, 1992};


int menge=sizeof(iarr)/sizeof(int);

int jz5[menge];

int jrest[menge];

int p=0, q=0;


for (int i=0; i<menge; i++)

{


    if((iarr[i]/10)%10==5)

        {

        jz5[p++]= iarr[i];

          }

    else

    jrest[q++]=iarr[i];

}


for (int i=0; i<menge; i++)

{

cout << jz5[i] << "\n";

}


for (int i=0; i<menge; i++)

{

cout << jrest[i] << "\n";

}


[/PHP]

also am einfachsten in diesem Fall wäre, wenn du dir nach dem einlesen der Daten ins Array ein Steuercode, wie z.B. '0000', ans ende schreibst und das dann als so ne art stringendezeichen betrachtest. beim auftreten dieses Zeichen unterbrichst du dann halt deine Datenausgabe.

[EDIT]

Warum kann mein Borland-Kompiler das nicht kompilieren??

Er meldet, dass für die Array-Deklaration ein Konstantenausdruck erforderlich ist.

Welcher Compiler meckert denn da nicht?

[/EDIT]

Hi, das geht mit Dev-C++

mit Streucode ist nicht so eine gute Sache, da ich es auch für Buchsttaben verwenden will - und es sollte schon danach nichts stehen ...

und wie soll ich wissen ab wann ich diesen Streucode einsetzten soll?

also den Code würdest du einfach so setzen:

for (int i=0; i<menge; i++)

{


   if((iarr[i]/10)%10==5)

       {

       jz5[p++]= iarr[i];

         }

   else

   jrest[q++]=iarr[i];

}


jz5[p] = 0;

jrest[q] = 0;

[/PHP]

Beim Buchstaben ist das mit dem Streucode ja noch unproblematischer. Da könnte man eben das String-Ende Zeichen '\0' verwenden.

Ansonsten kannst du natürlich auch folgendes machen:

1. Array wie bisher durchlaufen, aber nicht direkt die werte auf andere Arrays verteilen, sondern einfach nur counter hochzählen.

2. Über selbige Counter die beiden neuen arrays initialisieren

3. dann das programm wie bisher

hund555, du hst doch mit p und q genau die beiden Markierungen, die du brauchst:

for (int i=0; i<p; i++)

{

    cout << jz5[i] << "\n";

}


for (int i=0; i<q; i++)

{

    cout << jrest[i] << "\n";

}[/code]

@ bmg4ever

nein, geht nicht - weil ich bei erstellen mehr array erstellt habe ( int jz5[menge]; )

da wird ner nächte array-platz auf 0 gesetzt, und weiter wieder durcheinander.

@Klotzkopp:

gute idee, ist schon mal eine möglichkeit richtig auszugeben - nur es muss irgendwie möglich sein, arrays kleiner zu definieren, damit da weiter nichts steht.

nur es muss irgendwie möglich sein, arrays kleiner zu definieren, damit da weiter nichts steht.

natürlich ist das möglich.

ich zitiere:

--------------------------------------------------

1. Array wie bisher durchlaufen, aber nicht direkt die werte auf andere Arrays verteilen, sondern einfach nur counter hochzählen.

2. Über selbige Counter die beiden neuen arrays initialisieren

3. dann das programm wie bisher

--------------------------------------------------

also das wäre dann so:

 int iarr[]={1970, 1956, 1921, 1994, 1933, 1937,

1945, 1940, 1928, 1972, 1976, 1944, 1992, 1914,

1908, 1968, 1954, 1959, 1929, 1943, 1939, 1942,

1992, 1919, 1951, 1947, 1990, 1943, 1955, 1987,

1902, 1955, 1908, 1914, 1943, 1972, 1988, 1983,

1983, 1928, 1907, 1970, 1942, 1923, 1990, 1935,

1958, 1992};


int menge=sizeof(iarr)/sizeof(int);

int p=0, q=0;


for (int i=0; i<menge; i++)

{


    if((iarr[i]/10)%10==5)

        {

        p++;

          }

    else

    q++;

}


int jz5[p];

int jrest[q];



p=q=0;

for (i=0; i<menge; i++)

{


    if((iarr[i]/10)%10==5)

        {

        jz5[p++]= iarr[i];

          }

    else

    jrest[q++]=iarr[i];

}


for (i=0; i<sizeof(jz5)/sizeof(int); i++)

{

cout << jz5[i] << "\n";

}


for (i=0; i<sizeof(jrest)/sizeof(int); i++)

{

cout << jrest[i] << "\n";

}

[/PHP]

@ bmg4ever

du bist mein retter! optimale lösung.

(hast nur in den For-schleifen vergessen i zu definieren)

ich will ja nichts sagen, aber es reicht auch völlig, wenn man eine variable innerhalb einer funktion nur einmal deklariert.

andere compiler, z.b. der von VC++, meckern sogar über mehrfach deklarationen

andere compiler, z.b. der von VC++, meckern sogar über mehrfach deklarationen

Das ist aber ein Bug des Compilers von Visual C++ 6. Der Standard sagt, dass Variablen, die im Initialisierungsteil einer for-Schleife deklariert werden, nur innerhalb der Schleife gültig sind.

cool wusst ich auch noch nicht

Das ist aber ein Bug des Compilers von Visual C++ 6. Der Standard sagt, dass Variablen, die im Initialisierungsteil einer for-Schleife deklariert werden, nur innerhalb der Schleife gültig sind.

Aber ist das nicht eigentlich unlogisch?

Weil der Kopf ist ja außerhalb der Schleife und bei z.B. einer do-while kann ich als Bedingung auch nichts nehmen was innerhlb der Schleife angelegt wird.

Außerdem müsste dann doch auch folgendes Beispiel klappen

#include <stdio.h>


int main()

{

    for (i=0; i<10;++i)

	{

		int i;

	}

	return 0;

}

[/PHP]

Oder geht das nur bei meinem VC++6 nicht?

Nur mal so am Rande :floet:

Das ist aber ein Bug des Compilers von Visual C++ 6. Der Standard sagt, dass Variablen, die im Initialisierungsteil einer for-Schleife deklariert werden, nur innerhalb der Schleife gültig sind.

In der Version 7.1 vom VS (vermutlich aber auch bereits in früheren Versionen) ist das Verhalten dokumentiert. Durch Abschalten der Erweiterungen (/Za) oder durch /Zc:forScope kann das C++ Standard-Verhalten erzwungen werden.

Aber ist das nicht eigentlich unlogisch?

Weil der Kopf ist ja außerhalb der Schleife und bei z.B. einer do-while kann ich als Bedingung auch nichts nehmen was innerhlb der Schleife angelegt wird.

Es geht nur um den Initialisierungsteil der for-Schleife, also den Bereich zwischen der runden öffnenden Klammer und dem ersten Semikolon. So etwas gibt es do/while nicht.

Darum funktioniert auch dein Beispiel nicht

Ja schon klar, aber so wie es im Standard festgelegt ist bedeutet es doch das ich eine Variable vor einem Block {} anlege, diese aber nur innerhalb des Blockes gültig ist. Also so als wäre sie in ihm deklariert worden.

Das wirkt für mich inkonsequent und ich sehe nicht warum man sich so entschieden hat.

Um es nochmal zu verdeutlich könntem man es ja theoretisch mit folgendem Beispiel gleichsetzen:

int i=0;

{

   i = 5 //ok

}

i++; //geht nicht weil i unbekannt

[/PHP]

Das ist natürlich falsch weil i auch nach dem Block existiert, nach der for-schleifen logik würde es aber nicht existieren.

Ich suche halt den tiefern Sinn darin

Ja schon klar, aber so wie es im Standard festgelegt ist bedeutet es doch das ich eine Variable vor einem Block {} anlege, diese aber nur innerhalb des Blockes gültig ist. Also so als wäre sie in ihm deklariert worden.

Das wirkt für mich inkonsequent und ich sehe nicht warum man sich so entschieden hat.

Der Grund liegt beim for, das als eine abgekürzte Schreibweise für eine while-Schleife betrachtet werden kann. Wenn es kein for gäbe, würdest Du die Deklaration der Zählvariablen vermutlich auch im {}-Block vornehmen.

Aber letztlich ist es egal, irgendwie musste es festgelegt werden und es ist nun so festgelegt, wie es eben ist. Es gibt ja auch Compiler, die sich in dieser Beziehung Freiheiten für Abweichungen vom Standard nehmen.

Der Grund liegt beim for, das als eine abgekürzte Schreibweise für eine while-Schleife betrachtet werden kann. Wenn es kein for gäbe, würdest Du die Deklaration der Zählvariablen vermutlich auch im {}-Block vornehmen.

Eben nicht, weil du sie ja dann nicht in der Bedingung verwenden kannst. Das ist ja das Selbe wie mein 1. Beispiel.

Ich glaube, dass eine Variable, die im Kopf einer "for-Schleife" deklariert wird auch nur in jener Schelife gültig ist, hat einen Recht einfachen Grund:

Stell dir vor, du schreibst ein Programm, in dem 30 verschiedene "for-schleifen" verwendet werden. Da die Variable "i" in jeder dieser Schleifen neu initialisiert wird, kannst du sie auch immer wiederverwenden. Könntest du das nicht, müsstest du entweder "i" nach jeder "for-Schleife" wieder auf "0" (oder was auch immer der Startwert der folgenden Schleife ist) zurücksetzen, oder 30 verschiedene Zählvariablen einführen. Die Nachteile liegen hier klar auf der Hand.

mfg

Eben nicht, weil du sie ja dann nicht in der Bedingung verwenden kannst. Das ist ja das Selbe wie mein 1. Beispiel.

???

For-Schleifen sind vom Prinzip her vollkommen überflüssig, alles geht mit while Schleifen. Betrachte for nur als eine Bequemlichkeit, die der Compiler für Dich "umschreibt" und zwar in der Form:

for(int z=0;z<10;z++) { /* blah */ }

[/PHP]

wird z.B. zu

[PHP]
{
int z=0;
while(z++ < 10)
{
/* blah */
}
}

Je nach Compiler bzw. Einstellung werden unter Umständen die äußeren Klammern weggelassen, wodurch z auch nach dem for-Konstrukt nutzbar bleibt, was dann allerdings nicht mehr völlig dem Standard entspricht.

Ich verstehe nicht, was Du daran unlogisch findest. Und wenn doch, dann betrachte es doch einfach als gegebene Festlegung.

 

{

   int z=0;

   while(z++ < 10)

   {

      /* blah */

   }

}

[/PHP]

das ist nicht das selbe was du weiter oben geschreiben hast, denn danach

Wenn es kein for gäbe, würdest Du die Deklaration der Zählvariablen vermutlich auch im {}-Block vornehmen.

würde das z innerhalb des while blocks deklariert werden

Ich verstehe nicht, was Du daran unlogisch findest.

Wie gesagt ich finde es unlogisch das eine Variable die vor einem {}-Block deklariert ist nur innerhalb diesem gültig ist.

das ist nicht das selbe was du weiter oben geschreiben hast, denn danach

Wie gesagt ich finde es unlogisch das eine Variable die vor einem {}-Block deklariert ist nur innerhalb diesem gültig ist.

Doch doch, alles richtig , denn neben dem while{}-Block gibt es noch einen {}-Block. Bei mir wird z nicht im while-Block deklariert sondern im übergeordneten Block, der nichts anderes macht, als Deklaration und while-Block einzuschließen, damit für die Schleife deklarierte Variablen im weiteren Verlauf des Codes nicht mehr gültig sind. Wenn Du also das Verhalten von standardkonformen C++ for-Schleifen nachahmen willst, musst Du Deklaration und while wie in meinem Beispiel in einem {}-Block schachteln.

Jaja schon klar wenn man das standard konforme Verhalten nachahmen will muss man es so aufbauen.

ABER ( ) bei einer for Schleife sind ist der äußere {}-Block nunmal nicht da (auch wenn es so behandelt wird als wäre er da) und deshalb müsste die Variable eigentlich auch nach der Schleife gültig sein.

Jaja schon klar wenn man das standard konforme Verhalten nachahmen will muss man es so aufbauen.

ABER ( ) bei einer for Schleife sind ist der äußere {}-Block nunmal nicht da (auch wenn es so behandelt wird als wäre er da) und deshalb müsste die Variable eigentlich auch nach der Schleife gültig sein.

das haben sich die microsoft-entwickler wohl auch gedacht

Aber jetzt ist auch mal gut mit dieser diskussion.

Aber jetzt ist auch mal gut mit dieser diskussion.

Zwingt dich niemand dran teil zu nehmen