char array... elemente hinzufügen problem...

[Hevel]

Hi ...

folgende Stituation.

Ich habe ein char array. Einer Funktion wird ein Zeiger auf das Array
übergeben. In dieser Funktion soll an das Array mehrere Elemente noch
hinzugefügt werden.

Dazu der Bsp.: Code:

int Add(unsigned char * pArr)
{
  // array um 2 Elemente erweitern
     pArr[3] = 4;
     pArr[4] = 5;

  return 0;
}

int main(int argc, char* argv[])
{
   // Das Array mit 3 Elementen
      unsigned char Arr[] = {1,2,3};

   // an Funktion übergeben die 2 Elemente anfügt
      Add (&Arr[0]);

   // Danach hat das Array 5 Elemente...
   // die ich auch hier ausgeben kann... funzt einwandfrei.

   return 0;
}

Nun meine Frage: Das Array wird einfach erweitert, also über dessen Grenzen
hinaus in den Speicher geschrieben oder? Wenn ja, dann wäre das doch nicht
korrekt so! Was müsste ich da ändern?

Mal abgesehen davon funktioniert das ganze so wie es ist aber. Aber ich
glaube eben, dass es nicht ganz korrekt ist. *zweifel*

Danke euch, wenn ihr mir da Gewissheit verschaffen könntet.

MfG
Hevel

[Solaris'dUKe]

Mal abgesehen davon funktioniert das ganze so wie es ist aber. Aber ich
glaube eben, dass es nicht ganz korrekt ist. *zweifel*

Da ist dein Zweifel tatsächlich angebracht!
Du beschreibst ein Bereich der nicht dir gehört...

Die Grösse deines Arrays kannst du nicht so einfach ändern. Das geht nur
bei einem dynamisch erzeugten...
Schau dir mal alloc, realloc u.s.w. an... und schlag im Buch deines Vetrauens
mal unter Pointer nach...

[Edit: URL Korrektur]
http://wwwcgi.rdg.ac.uk/cgi-bin/cgiwrap/wsi14/poplog/man/3C/realloc

[ Dieser Beitrag wurde am 12.12.2002 um 19:06 Uhr von Solaris'dUKe editiert. ]

[guard]

Ich hab mir mal die Mühe gemacht und dir das Dingen ausprogrammiert. Hatte momentan eh Langeweile

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

int Add( char* pArr )
{   
   //array um 2 elemt. erw.
   if( ( pArr = ( char* )realloc( pArr, 5 ) ) != NULL )
   {
      fprintf( stdout, "\nArray um 2 Elemente erweitert!\n" );
      pArr[3] = 4;
      pArr[4] = 5;

      fprintf( stdout, "\nArr[0] = %d", pArr[0] );
      fprintf( stdout, "\nArr[1] = %d", pArr[1] );
      fprintf( stdout, "\nArr[2] = %d", pArr[2] );
      fprintf( stdout, "\nArr[3] = %d", pArr[3] );
      fprintf( stdout, "\nArr[4] = %d\n\n", pArr[4] );

      free( pArr );
   }

   else
   {
      perror( "(Add:) test" );
      fprintf( stderr, "(Add:) Es lief etwas schief!\n\n" );

      return( EXIT_FAILURE );
   }

   return( 0 );
}

int main( void ) 
{
   char* Arr;   

   if( ( Arr = ( char* )malloc( 3 * sizeof( char ) + 1 ) ) != NULL )
   {
      fprintf( stdout, "\nFeld allokiert!\n" );

      Arr[0] = 1;
      Arr[1] = 2;
      Arr[2] = 3;

      fprintf( stdout, "\nArr[0] = %d", Arr[0] );
      fprintf( stdout, "\nArr[1] = %d", Arr[1] );
      fprintf( stdout, "\nArr[2] = %d\n\n", Arr[2] );
   }

   else
   {
      perror( "(main:) test" );
      fprintf( stderr, "\n(main:) Es lief etwas schief!\n\n" );

      return( EXIT_FAILURE );
   }

   Add( Arr );

   /*--- "system()" ist aber kein ANSI-Standard ;) ---*/
   system( "PAUSE" );

   return( 0 );
}

Also funzt bei mir einwandfrei ...

MfG

[Solaris'dUKe]

Eigentlich wollte ich das er das selbst herleitet...

Aber wie auch immer ...

char* Arr;

.... ist böse... denn bei

if(!Arr)
{
// allokiere Arr
}

.. fällt man auf die Fre***
Also
char *Arr = 0; // nie uninitialisierte Variabeln!

und "free( pArr );" ist auch nicht so nett.. denn schliesslich
hast du den Pointer im Hauptprogramm allokiert...

[guard]

... gut ... wenn ich jetzt so darüber nachdenke, hast irgendwie schon recht

MfG

[Hevel]

Hi... ich danke euch beiden erstmal... habt mir echt geholfen.

Und Solaris'dUKe, ich hatte es mir so fast selbst hergeleitet, nur
nicht mit soner schönen Fehlerabfrage... aber hast schon recht.. selbst
hergeleitet ist mehr verstanden. Nun, so verstehe ich das Bsp. von guard
jetz.

Trotzdem Danke guard

Ich habe nur ein Probl noch, was mir nicht gefällt, und woran ich echt noch hänge:

mir gefällt das

Arr[0] = 1;
Arr[1] = 2;
Arr[2] = 3;

nicht. Es funktioniert zwar, aber was wenn ich ca 40 Elemente einfügen will?
Dann wirds auf wendig. z.B. Arr[38] = {0,20,20,20,4,5,6,7,...};
geht da wohl nicht.. leider.
Gibts das was anderes?

Und nochwas... wie bekomme ich nun die Anzahl der Elemente?
sizeof liefert die Byteanzahl des Zeigers. ... brauch ich nicht.

= 0; ...

= '0';

= 0; weil ich später

auslese und binär darstelle und da muß 0 auch 00000000b ergeben

und nicht '0' also 00110000b = 48d;

Und da weiß ich nun ich wie ich an die Anzahl der Elemente komme. Sind ja
keine chars sondern irgendwie 8 Bit int. oder?

MfG
Hevel

[Solaris'dUKe]

hatte es mir so fast selbst hergeleitet

freut mich

was wenn ich ca 40 Elemente einfügen will

40 total unterschiedliche Elemente einzufügen sind tatsächlich
handarbeit.... bei einer Zahlenreihe (1-40) kannst du ja ne "for" verwenden..

= 0; ...

Das hoff ich doch
Für strlen ist dort fertig, wo NULL kommt. Es ist gedacht für
Strings (Zeichenkette) und nicht für Zahlenreihen...

Und da weiß ich nun ich wie ich an die Anzahl der Elemente komme. Sind ja
keine chars sondern irgendwie 8 Bit int. oder?

Wieso soll ein *char nicht auf ein Char zeigen? Natürlich ist das ein
Char-Array... wobei natürlich das eine nicht das andere aussschliesst

Und wenn du Null auch in deinem Array haben kannst (z.b. {1,2,3,9,0,7,6})
wird dir nichts anderes übrigbleiben, als dein Array genau so gross zu machen
wie du ihn brauchst, bei jedem neuen Element das Teil vergrössern und nebenher
mitzuzählen...
Es sei denn du findest eine andere Endmarkierung als Null...

[Hevel]

nochmal ich...

hab das

Arr[0] = 1;
Arr[1] = 2;
Arr[2] = 3;

Problem jetzt so gelöst:

// Array anlegen und mit Werten initialisieren
  unsigned char tmpArr[] = {0,1,2,3,4,5,6,7,8,9...};

  // Zeiger anlegen Speicher alloc...
  Arr = ( char* )malloc(sizeof(tmpArr) * sizeof( char ));

  // in Schleife Werte übertragen
  for(int i = 0; i < sizeof(tmpArr); i++)
   {
     Arr[i] = tmpArr[i];
   };

Das ist zwar etwas speicherfressen, aber es erspart mir ne meng Tiparbeit..

Hoffe es gefällt...

MfG

[guard]

Original erstellt von <Hevel>:
Das ist zwar etwas speicherfressen, aber es erspart mir ne meng Tiparbeit..

Da hast du wohl war, es erspart. Aber vergiss nicht den Speicher wieder freizugeben und davor noch zu testen ob die Allokierung erfolgreich war

MfG

[Hevel]

Nochmal ne Grundlagenfrage an guard .. aber auch alle anderen.

Ist die Speichererweiterung mit realloc für pArr in der Funktion

int Add( char* pArr )

nur in dieser Funktion gültig?

Oder besitzt nun Arr in main() auch die erweiterte Speichergröße?
Meiner Meinung nach müsste das so sein, da pArr auf Arr zeigt und
so mit alle Änderungen an pArr auch für Arr gelten müssten.

Komischer Weise.. ist das wenn ich das Prog in Borland C++ kompiliere so!
Aber ich habs mal in VC++ eingefügt und 2-3 Schönheitsanpassungen gemacht,
aber am Code selbst nix verändert und siehe da... in VC ist das nicht so,
sondern dort gilt realloc nur innerhalb der Funktion!

Wie ist das zu erklären, bzw. was wäre rein logisch richtig?

Danke.

MfG
Hevel

[Shade Of Mine]

Add(char* p)

p ist eine kopie von &Arr[0] - wenn du jetzt willst, das Arr auf etwas anderes zeigt, musst du einen zeiger auf &Arr[0] übergeben

Add(char** p)

[Hevel]

@ Shade Of Mine:

Um die Änderung für Arr zumachen habe ich die Zeile
so abgeändert. Dann gehts, dann wird die relloc-
Änderung bei Arr gemacht.

vorher: if( ( pArr = ( char* )realloc( pArr, 5 ) ) != NULL )
nachher: if( ( *pArr = ( char* )realloc( *pArr, 5 ) ) != NULL )

Ist das so korrekt?

Und dann noch ne Unklarheit.

Ich habe man den Code von guard so abgeändert, dass mir die
Länge von Arr ausgegeben wird und durch eine schleife, alle
Element. Das verblüffende ist nun, das strlen(Arr) = 9 ist,
obwohl nur 3 Elemente hinzugefügt wurden!!!??

int main( void ) 
{
   char* Arr; 
   int i=0;

   if( ( Arr = ( char* )malloc( 3 * sizeof( char ) + 1 ) ) != NULL )
   {
      fprintf( stdout, "\nFeld allokiert!\n" );

      Arr[0] = 1;
      Arr[1] = 2;
      Arr[2] = 3;

      fprintf( stdout, "\nArr[0] = %d", Arr[0] );
      fprintf( stdout, "\nArr[1] = %d", Arr[1] );
      fprintf( stdout, "\nArr[2] = %d\n\n", Arr[2] );

      /* Eingefügt */
      for ( i = 0; i < strlen(Arr); i++)
      {
          fprintf( stdout, "\nArr[%d] = %d",i, Arr[i] );

      }

      fprintf( stdout, "\nstrlen(Arr) = %d\n\n", strlen(Arr) );
      /* Ende eingefügt */

   }

   else
   {
      perror( "(main:) test" );
      fprintf( stderr, "\n(main:) Es lief etwas schief!\n\n" );

      return( EXIT_FAILURE );
   }

   Add( Arr );

   /*--- "system()" ist aber kein ANSI-Standard ;) ---*/
   system( "PAUSE" );

   free( Arr );

   return( 0 );
}

Da werd ich nun nicht ganz schlau draus. Ihr?

MfG
Hevel

[Hevel]

Sorry!

Die nachher Zeile mu? so lauten;

nachher: if( ( *pArr = ( char* )realloc(pArr, 5 ) ) != NULL )

[Shade Of Mine]

die änderung ist richtig!

strlen() macht nichts anderes als:

int strlen(char* str)
{
int i=0;
while(str[i]!=0)++i;
return i;
}

du siehst: strlen sucht nur nach 0
du musst dir selber merken wie groß dein array ist!

[Hevel]

Danke Shade Of Mine.

Nur hab ich da noch Fehler gefunden.

Hab ein char * cArr;
cArr[0] = 0;
cArr[0] = 1;
cArr[0] = 2;

nach der Funktion Add() mit realloc ist cArr[0] = 192, seit dem ich die
Änderung an

if( ( *pArr = ( char* )realloc(pArr, 5 ) ) != NULL )

gemacht habe. sollte aber immernoch 0 sein.
Verstehe wer will...

Ja, da hast du Recht strlen sucht nur nach 0, aber in dem
Bsp ist keine 0 vorhanden, sondern 1,2,3 und trotzdem
ist strlen(Arr) = 9 !!?? hmm... keine Ahnung mehr hab...

MfG