Array fixer Länge an Funktion übergeben

Naja, sizeof funkt zwar, aber ist eigentlich unnötig da ja die 
Arraygröße eh im Prototyp (und damit im aktuellen Objekt irgendwo) 
bekannt ist :-)

Gut, es handelt sich um 2 charakter Zeichen. Immer 2, nicht mehr und 
nicht weniger. Der Aufruf erfolgt mit Test("AB");, schade das sich das 
nicht belassen lässt.

ich schrieb:
> Gut, es handelt sich um 2 charakter Zeichen. Immer 2, nicht mehr und
> nicht weniger.

Das das Array dabei die Länge 3 hat, ist dir aber bewusst, oder ?

Oliver

Hallo, ich habe mit den Pointern doch ein Problem.

Prototyp ist z. B. der

1

void test( char *);

Funktionsaufruf

1

test("ABCD");

wird automatisch die Addresse der Speicherstelle von "A" übergeben oder?

wie muss jetzt die Funktion selbst aussehen?

1

void test(char foo[5])

2

{

3

    char lokales_arr[5];

4

5

    hier dann ursprüngliches array in neues array kopieren;

6

}

funktioniert, ich vermute aber das das Ganze nicht sauber ist, weil ich 
ja ein Array in den Funktionsparameter angebe, aber ein Pointer 
übergeben wird? Wie muss das Ganze stattdessen aussehen?

Ich möchte quasi die übergebenen Zeichen ABCD in ein anderes Array 
kopieren, welches noch andere Daten enthält.

Da reinkopieren ist sicher kein Problem, da es immer eine bestimmte 
Länge ist und ich den Nullterminierung nicht brauche.

Ich habe ein Array "01234567890" und an Position 4 soll die 
Zeichenfolge, die an die Funktion übergeben wurde, kopiert werden. 
"0123ABCD890".

Allerdings geht es mir um den Funktionskopf,

1

void test(char foo[5])

 da ist meiner Meinung nch etwas faul, weil sie ja nicht mit dem 
Funktionsprototypen übereinstimmt.

Malte S. schrieb:
> Der lautet dann auchvoid test(char* foo)
> Warum willst du die vereinbarte Länge da unbedingt drin haben. Mehr als
> eine Vereinbarung ist sie eh nicht.

Muss nicht zwingend drinn sein, ist aber übersichtlicher.


Ok also void test(char* foo) und der Zugriff auf die einzelnen Elemente 
wie?

ich schrieb:
> Ok also void test(char* foo) und der Zugriff auf die einzelnen Elemente
> wie?

foo[1] oder *(foo+1)

Malte S. schrieb:
> Aber nur, wenn du absolut garantieren kannst, dass test() immer ein
> ausreichend langes Array übergeben wird.

Seit C99 geht das teilweise:

1

char test(char foo[static 2]) {

2

    return foo[1];

3

}

So deklariert darf man keinen Nullpointer und kein Array mit einer Länge 
von weniger als zwei Elementen an die Funktion übergeben.

Arne Nonymous schrieb:
> So deklariert darf man keinen Nullpointer und kein Array mit einer Länge
> von weniger als zwei Elementen an die Funktion übergeben.

und woher soll der compiler die länge wissen?

int i = rand(10);
int* a = (int*)malloc(sizeof(int)*i);
//oder c++ int[] a  = new int[i];

test(a) {
}

Suchst Du so was?

1

#include <stdio.h>

2

#include <string.h>

3

4

typedef struct

5

{

6

  char ch[3];

7

} String3_s;

8

9

void func( String3_s string3 )

10

{

11

  printf( "%s\n", &string3.ch[0] );

12

  printf( "%lu\n", sizeof( string3 ) );

13

}

14

15

int main( void )

16

{

17

    // C89

18

    //String3_s string3;

19

    //strcpy( &string3.ch[0], "AB" );

20

21

    // C99

22

    String3_s string3 = { .ch = "AB" };

23

  func( string3 );

24

}

25

26

27

}

Ausgabe:
fjhf@hjhgjk:~/test$ ./a.out
AB
3

Gruss,
Manni

Sorry, da ist eine Klammer zu viel, keine Ahnung wo die herkommt.
Muss mal die Anleitung zum Forum lesen.

Gruß,
Manni

Elegant & sicher geht so:

1

#include <iostream>

2

#include <array>

3

4

void fun (std::array<int,7> arr) {

5

  for(auto x : arr) {

6

    std::cout << x;

7

  }

8

}

9

10

void fun2 (const std::array<int,7>& arr) {

11

  for(auto x : arr) {

12

    std::cout << x;

13

  }

14

}

15

16

int main () {

17

  fun ({{1, 2, 3, 4, 5, 6, 7}});

18

  fun2 ({{1, 2, 3, 4, 5, 6, 7}});

19

}

So ist auch sichergestellt dass man nicht zu viel übergibt, und dass, 
falls man zu wenig übergibt, die anderen Elemente default-initialisiert 
werden (Integer auf 0, Klassen per Default-Konstruktor) - somit keine 
Speicherfehler möglich. Die 1. Variante kopiert dabei den kompletten 
Inhalt in den Funktions-scope, die 2. übergibt nur eine Referenz 
(normalerweise schneller).

PS: So funktioniert sogar sizeof(arr) und arr.size() "sinnvoll".

Also bei mir würde die Funktion auch so aussehen:

1

char* teilstring(const char* string, unsigned int groesse)

2

{

3

  char *teilstring = (char*)malloc(sizeof(char)*(groesse+1));

4

  teilstring[groesse]='\0';

5

6

  for(unsigned int counter=0;counter<groesse; counter++) teilstring[counter]=string[counter];

7

8

  return teilstring;

9

}

Man übergibt einen String als Pointer und eine Variable für die Größe 
des Rückgabestrings.
Übergibt man also ein String/Array mit Inhalt "Hallo Welt!" und Größe=4 
dann wird "Hall" zurückgegeben... Da ist aber noch nicht die mögliche 
Überlänge von int groesse in Bezug auf die tatsächliche Länge des Arrays 
berücksichtigt!

Hier mit Überlängenkorrektur:

1

char* teilstring(char* string, unsigned int groesse)

2

{

3

  char *teilstring = (char*)malloc(sizeof(char)*(groesse+1));

4

  teilstring[groesse]='\0';

5

6

  for(unsigned int counter=0;counter<groesse; counter++)

7

  {

8

    teilstring[counter]=string[counter];

9

    if (string[counter]=='\0') break;

10

  }

11

12

  return teilstring;

13

}

Martin schrieb:
> Also bei mir würde die Funktion auch so aussehen:
Das ist genau das gleiche was strndup macht?! Btw, sizeof(char) ist 
immer 1, das kann man also weglassen.