beliebig großes int array

Hallo, also ich habe hier eine schleife die bestimmte zahlen berechnet, und ein paar dieser zahlen wollte ich in einem array speichern.

das array soll so groß sein wie es gebraucht wird, bsp:

for(i=1;i<=100;i++) {
   int bla[] = i;
}

also so habe ichs mir vorgestellt, der sinn sollte erkennbar sein, (dass die durch die schleife berechnete zahl in ein int array gespeichert werden soll (abhängig von der anzahl der errechneten zahlen))

gruß

Mario Sandler

Dazu musst du Speicherplatz dynamisch anfordern
mithilfe von malloc():

#include <stdio.h>
#include <stdlib.h>

int main() {

        unsigned * array;
        unsigned input;
        unsigned i;

        //Array Größe einlesen
        printf("Größe des Arrays angeben: ");
        scanf("%d",&input);

        //Array-Speicher anfordern
        array = malloc(sizeof(unsigned)*input);

        //Array füllen
        for(i=0;i<input;i++)
                array[i] = i;

        //Array ausgeben
        for(i=0;i<input;i++)
                printf("%d\n",array[i]);

        return 0;

}

Solltest du erst in der Schleife erfahren wieviel Speicherplatz du benötigst
kannst du mithilfe von realloc() dein Speicherplatz vergrößern.

//EDIT:
Ok hab den Cast weg, ist schließlich das Ansi C Forum

Storm.Xapek.de schrieb:

array = (unsigned*) malloc(sizeof(unsigned)*input);

Den Cast weglassen, dann stimmts.

oh, da habt ihr mich nun glaube ich missverstanden.

sagen wir wir haben eine schleife die von 1 - 30 zählt, und mein algorithmus aus der zahlenkette auf bestimmte werte kommt (2,4,6,8,10,12,...) dann soll in das array nur die zahlen die der algorithmus errechnet hat.

bei 1 - 10 wären es: 2,4,6,8,10
bei 1 - 16 wären es: 2,4,6,8,10,12,14,16

also es kommt darauf an bis wohin er zählen soll (je mehr er zählen muss, umso mehr zahlen findet der algorithmus (und soll sie auch speichern)

bei 1 - 10 brauch das array halt nur 5 stellen groß sein,
bei 1 - 16 soll das array 8 stellen groß sein

und natürlich auch mit den gefundenen werten gefüllt werden.

mfg

Mario Sandler

Für dieses Problem brauchst du malloc() und realloc().
Erst forderst du etwas Speicher an mit malloc(),
wenn du dann mehr brauchst erweiterst du ihn mit realloc().

Wie das funktioniert kannst du in dem Beispiel nachvollziehen
(und zu realloc dürfte es auch einige Beispiele geben)

//Edit:
Hab sogar extra für dich eins gefunden:

/* realloc example: rememb-o-matic */
#include <stdio.h>
#include <stdlib.h>

int main ()
{
  int input,n;
  int count=0;
  int * numbers = NULL;

  do {
     printf ("Enter an integer value (0 to end): ");
     scanf ("%d", &input);
     count++;
     numbers = (int*) realloc (numbers, count * sizeof(int));
     if (numbers==NULL)
       { puts ("Error (re)allocating memory"); exit (1); }
     numbers[count-1]=input;
  } while (input!=0);

  printf ("Numbers entered: ");
  for (n=0;n<count;n++) printf ("%d ",numbers[n]);
  free (numbers);

  return 0;
}

http://www.cplusplus.com/reference/clibrary/cstdlib/realloc.html

kannst du mir eventuell ein beispiel schreiben?

ich habe erst vor 2 wochen mit programmieren angefangen und verstehe das nicht.

Ich wäre sehr dankbar.

gruß

Der Code ist nicht wirklich gelungen. Zum einen ist es nicht sonderlich sinnvoll realloc() für ein einzelnes (Mehr-)Zeichen aufzurufen (Speichergröße verdoppeln ist hier die allgemein gängige Strategie), zum anderen sollte man den an realloc() übergebenen Pointer nicht gleich mit dem Rückgabepointer überschreiben. Denn wenn realloc() aus irgendeinem Grund fehlschlägt, dann weiss man nicht mehr wo der zuvor (erfolgreich) reservierte Speicher liegt und kann ihn dann weder freigeben noch (was wohl noch kritischer ist) kommt man an die darin abgelegten Daten heran.

Hallo, beliebig groß geht nicht. Nur soviel, wie dein Betriebssytem hergibt.

Es folgen zwei Versionen,
die zweite ist mit steigender Anzahl hinzukommender Speicherblöcke wesentlich schneller, weil
die Funktion realloc insgesamt erheblich weniger Zeiger umkopiert.
Wenn die Anzahl der Blöcke, die dazukommen, nicht allzu groß wird,
dann reicht auch Variante Nr.1

// Zehn Millionen Integer ( 40 MB bei sizeof(unsigned int) = 4 )
#define BLOCK_SIZE 10000000 

#include <stdio.h>
#include <stdlib.h>
#include <limits.h>

int main()
{
	unsigned int* piSavePtr = NULL, *piArray = NULL;
	unsigned int i = 0, j = 0;
 	// Den ersten Block organisieren
	piArray = malloc( BLOCK_SIZE * sizeof ( unsigned int ) );
	// Prüfen, ob malloc erfolgreich war
	if ( NULL == piArray )
	{
		puts("Out of memory"); 
		return 1;
	}
	// Gehe durch die Schleife von i = 0 bis i = UINT_MAX 
	for( i = 0; i <= UINT_MAX; i++ )
	{
		 // Wenn i nicht durch 2 teibar ist, weiter machen.
		if ( i % 2 ) continue;
		// Prüfe ob ein neuer Speicherblock reserviert werden muss.
		if ( 0 ==  ( j % BLOCK_SIZE ) && j > 0 ) 
		{
			printf("Info: Neuer Speicherblock wird reserviert.\n", j );

			piSavePtr = piArray; // Zeiger sichern, falls realloc NULL liefert.
			if ( NULL == ( piArray = realloc( piArray, ( j / BLOCK_SIZE + 1 )
									* BLOCK_SIZE * sizeof( unsigned int ) ) ) )
			{
				puts("Out of memory"); 
				piArray = piSavePtr;    // Zeiger wieder herstellen.
				break;
			}
 			printf("Info: Reservierung OK. %.0f Mega Byte im Block\n",	
				( j / BLOCK_SIZE + 1.0 ) * BLOCK_SIZE * sizeof( unsigned int )/
																		1E+6 );
		}
		piArray[j] = i; j++;    // i ist ohne Rest durch 2 teilbar.
	}
	// ggf. Array speichern, anzeigen, etc.
	// ...
	free ( piArray ); // Reservierten Speicherplatz freigeben.
	return 0;
}

Variante 2

int main()
{
	unsigned int** piSavePtr = NULL, **piArray = NULL;
	unsigned int i = 0, j = 0, k = 0;
	// Einen Zeiger auf den ersten Block organisieren
	piArray = malloc( 1 * sizeof ( unsigned int* ) );
	if ( NULL == piArray  )
	{
		puts("Out of memory"); 
		return 1;
	}
	// Den ersten Block organisieren
	piArray[0] = malloc( BLOCK_SIZE * sizeof ( unsigned int ) );
	// Prüfen, ob malloc erfolgreich war
	if ( NULL == piArray[0]  )
	{
		puts("Out of memory"); 
		free ( piArray );
		return 1;
	}
	// Gehe durch die Schleife von i = 0 bis i = UINT_MAX 
	for( i = 0; i <= UINT_MAX; i++ )
	{
		// Wenn i nicht durch 2 teibar ist, weiter machen.
		if ( i % 2 ) continue; 
		// Prüfe ob ein neuer Speicherblock reserviert werden muss.
		if ( 0 ==  ( j % BLOCK_SIZE ) && j > 0 ) 
		{	
			printf("Info: Neuer Speicherblock wird reserviert.\n", j );
			k++;	// Es kommt ein Zeiger dazu. 
			j = 0;	// Jeder Zeiger zeigt auf einen Bock der Größe BLOCK_SIZE.
			// Zeiger sichern, falls realloc NULL liefert.
			piSavePtr = piArray;
			// Einen neuen Zeiger auf den nächsten Block organisieren
			if ( NULL == ( piArray = realloc( piArray, (k+1) * 
									sizeof ( unsigned int* ) ) ) )  
			{
				puts("Out of memory"); 
				piArray = piSavePtr; // Zeiger wieder herstellen.
			}
			// Den nächsten Block reservieren.
			if ( NULL == ( piArray[k] = malloc( BLOCK_SIZE *
											sizeof( unsigned int ) ) ) )
			{
				puts("Out of memory");
			 	break;						// Beendet die for-Schleife
			}
 			printf("Info: Reservierung OK. Insgesamt  %.0f Mega Byte reserviert\n",
							(k+1) * BLOCK_SIZE * sizeof( unsigned int ) / 1E+6 );
		}
		piArray[k][j] = i; j++;    // i ist ohne Rest durch 2 teilbar.
	}
	// ggf. Array speichern, anzeigen, etc.
	// ...
	// Reservierten Speicherplatz freigeben.
	for ( i = 0; i < k; i++ ) 
	{
		free( piArray[i] );
	}
	free ( piArray );
	return 0;
}

MfG

Edit:
Nach Zeile 39 in Variante 2 sollte noch ein break rein.

Undertaker

Tim schrieb:

Zum einen ist es nicht sonderlich sinnvoll realloc() für ein einzelnes (Mehr-)Zeichen aufzurufen (Speichergröße verdoppeln ist hier die allgemein gängige Strategie)

aber solche strategien sollte man, trotzdem sie oft verwendet werden, mit vorsicht geniessen...