Array fixer Länge an Funktion übergeben

[ich (Gast)]

Hallo,
um arrays an Funktionen zu übergeben, bietet sich ja ein Pointer an. 
Gibt es auch noch andere Möglichkeiten um ein Array mit einer fixen 
Größe an die Fkt. zu übergeben? Wie muss dann der funktionsprototyp 
aussehen?

[Konrad S. (maybee)]

void f( int a[42] );

[Klaus W. (mfgkw)]

(was aber faktisch aufs selbe rauskommt, eine Feldgrenzenüberprüfung 
o.ä. kann man da nicht erwarten...)

[Konrad S. (maybee)]

So ist es.
Der sizeof-Operator lässt sich noch anwenden und die Größenangabe kann 
das Lesen des Codes erleichtern. Ich kann mich allerdings nicht daran 
erinnern, dass ich dieses Konstrukt in eigenem Code mal eingesetzt 
hätte. Pointer beißen nicht!

[Möp (Gast)]

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 :-)

[Konrad S. (maybee)]

Ja, genau, deswegen arbeite ich da nur mit Pointern.

[ich (Gast)]

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.

[Oliver (Gast)]

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

[Karl H. (kbuchegg)]

Konrad S. schrieb:
> void f( int a[42] );

*Vorsicht!*
Das ist nichts anderes als eine glorifizierte andere Schreibweise für

void f( int* a);

nicht mehr und nicht weniger.
Da steckt NICHT mehr dahinter, auch wenn die Schreibweise da was anderes 
suggeriert.

#include <stdio.h>

void f( int a[42] )
{
  printf( "%d\n", sizeof( a ) );
}

int main()
{
  int b[9];

  f( b );
}

Die Ausgabe ist 4, weil auf meinem System ein Pointer 4 Bytes groß ist! 
Die Ausgabe hat nichts mit der tatsächlichen Größe von a innerhalb der 
Funktion oder gar mit der Arraygröße des Aufrufers zu tun!

Arrays werden in C an Funktionen übergeben, in dem die Startadresse des 
Arrays übergeben wird und die empfangende Funktion hat dafür eine 
passende Pointer Variable bereitzustellen. Punkt.


Meine persönlichen Meinung nach, sollte man um sowas

void f( int a[42] );

einen Bogen machen. Auf den ersten Blick mag das für Neulinge einfacher 
erscheinen. Ist es aber nicht. Denn hier werden unterschwellig Dinge 
suggeriert, die einfach nicht zutreffend sind. Die Arrayangabe oder gar 
die Angabe der Arraygröße haben an dieser Stelle absolut nichts zu 
sagen! Dei Arrayangabe kann an den Aufrufer noch ein gewisses Signal 
sein, wie der Parameter von der Funktion verwendet werden wird, was 
gegenüber Pointer ein gewisser dokumentarischer Vorteil sein kann. Aber 
wir wissen alle, wie das mit derartigen Konventionen ist .... man kann 
sich einfach nicht auf sie verlassen, solange sie nicht vom Compiler 
eingefordert und überprüft werden.

[ich (Gast)]

Hallo, ich habe mit den Pointern doch ein Problem.

Prototyp ist z. B. der

void test( char *);

Funktionsaufruf

test("ABCD");

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

wie muss jetzt die Funktion selbst aussehen?

void test(char foo[5])
{
    char lokales_arr[5];

    hier dann ursprüngliches array in neues array kopieren;
}

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.

[Dennis S. (eltio)]

Da ein ordentlicher "String" in C eine Nullterminierung hat, könntest du 
das in einer While-Schleife Zeichen für Zeichen kopieren. strncpy sollte 
auch gehen, denke ich.

Gruß Dennis

[ich (Gast)]

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,

void test(char foo[5])

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

[Malte S. (maltest)]

Der lautet dann auch

void test(char* foo)

Warum willst du die vereinbarte Länge da unbedingt drin haben. Mehr als 
eine Vereinbarung ist sie eh nicht.

[ich (Gast)]

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?

[Peter II (Gast)]

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

foo[1] oder *(foo+1)

[Malte S. (maltest)]

char test(char* foo) {
    return foo[1];
}

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

[Malte S. (maltest)]

Willkommen in der wunderbaren Welt der Arrays und Pointer in C. Sie kann 
dir zu Füßen liegen oder unter selbigen zusammenbrechen. Das 
vollständige Verständnis jeder Indizierung und jeder Dereferenzierung, 
der Überblick über Herkunft und Zuverlässigkeit der Daten (Strings z.B.) 
und entsprechendes Einhalten der Grenzen des jeweiligen Speicherbereichs 
- ob in Gestellt eines Arrays oder eines blanken Pointers - helfen dir, 
dass am Ende nicht alles zusammenbricht ;)

[Arne Nonymous (Gast)]

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

Seit C99 geht das teilweise:

char test(char foo[static 2]) {
    return foo[1];
}

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

[Peter II (Gast)]

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) {
}

[Yalu X. (yalu) (Moderator)]

Peter II schrieb:
> 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?

Der Compiler weiß das nicht und muss es auch nicht wissen. Das [static 
2] ist lediglich eine Zusicherung des Programmierers, dass das Array 
mindestens 2 Elemente enthält und kann vom Compiler zu 
Optimierungszwecken verwendet werden. Für die Einhaltung dieser 
Zusicherung ist der Programmierer aber selber verantwortlich. Der 
Compiler überprüft sie nicht notwendigerweise.

[Konrad S. (maybee)]

Karl Heinz Buchegger schrieb:
> Die Ausgabe ist 4, weil auf meinem System ein Pointer 4 Bytes groß ist!

Uppps, Asche auf mein Haupt!

[Manni (Gast)]

Suchst Du so was?

#include <stdio.h>
#include <string.h>

typedef struct
{
  char ch[3];
} String3_s;

void func( String3_s string3 )
{
  printf( "%s\n", &string3.ch[0] );
  printf( "%lu\n", sizeof( string3 ) );
}

int main( void )
{
    // C89
    //String3_s string3;
    //strcpy( &string3.ch[0], "AB" );
  
    // C99
    String3_s string3 = { .ch = "AB" };
  func( string3 );
}
  
  
}

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

Gruss,
Manni

[Manni (Gast)]

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

Gruß,
Manni

[Dr. Sommer (Gast)]

Elegant & sicher geht so:

#include <iostream>
#include <array>

void fun (std::array<int,7> arr) {
  for(auto x : arr) {
    std::cout << x;
  }
}

void fun2 (const std::array<int,7>& arr) {
  for(auto x : arr) {
    std::cout << x;
  }
}

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

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).

[Dr. Sommer (Gast)]

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

[Martin (Gast)]

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

char* teilstring(const char* string, unsigned int groesse)
{
  char *teilstring = (char*)malloc(sizeof(char)*(groesse+1));
  teilstring[groesse]='\0';

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

  return teilstring;
}

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!

[Martin (Gast)]

Hier mit Überlängenkorrektur:

char* teilstring(char* string, unsigned int groesse)
{
  char *teilstring = (char*)malloc(sizeof(char)*(groesse+1));
  teilstring[groesse]='\0';

  for(unsigned int counter=0;counter<groesse; counter++)
  {
    teilstring[counter]=string[counter];
    if (string[counter]=='\0') break;
  }

  return teilstring;
}

[Dr. Sommer (Gast)]

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.

[Rufus Τ. F. (rufus)]

Manni schrieb:
> //strcpy( &string3.ch[0], "AB" );

Das geht auch lesbarer:

strcpy(string3.ch, "AB");