web-dev-qa-db-de.com

C ++ - Übergabe eines Array-Zeigers als Funktionsargument

Ich versuche, Zeiger von Arrays als Argumente für eine Funktion zu verwenden, die ein Array generiert.

void generateArray(int *a[],  int *si){
  srand(time(0));
  for (int j=0;j<*si;j++)
       *a[j]=(0+Rand()%9);
} //end generateArray;

int main() {
  const int size=5;
  int a[size];

  generateArray(&a, &size);

  return 0;
} //end main

Aber wenn ich das kompiliere, erscheint diese Meldung:

cannot convert `int (*)[5]' to `int**' for argument `1' to `void generateArray(int**, int*)'
34
Ortharios

Du machst es dir zu kompliziert - es muss nur sein:

void generateArray(int *a, int si)
{
    for (int j = 0; j < si; j++)
        a[j] = Rand() % 9;
}

int main()
{
    const int size=5;
    int a[size];

    generateArray(a, size);

    return 0;
}

Wenn Sie ein Array als Parameter an eine Funktion übergeben, wird es zu einem Zeiger auf das erste Element des Arrays. Normalerweise muss also nie ein Zeiger auf ein Array übergeben werden.

68
Paul R

int *a[] ist bei Verwendung als Funktionsparameter (aber nicht in normalen Deklarationen) ein Zeiger auf einen Zeiger, kein Zeiger auf ein Array (in normalen Deklarationen ist es ein Array von Zeigern). Ein Zeiger auf ein Array sieht folgendermaßen aus:

int (*aptr)[N]

Wobei N eine bestimmte positive ganze Zahl ist (keine Variable).

Wenn Sie Ihre Funktion zu einer Vorlage machen, können Sie dies tun und müssen nicht einmal die Größe des Arrays übergeben (da dies automatisch abgeleitet wird):

template<size_t SZ>
void generateArray(int (*aptr)[SZ])
{
    for (size_t i=0; i<SZ; ++i)
        (*aptr)[i] = Rand() % 9;
}

int main()
{    
    int a[5];    
    generateArray(&a);
}

Sie könnten auch eine Referenz nehmen:

template<size_t SZ>
void generateArray(int (&arr)[SZ])
{
    for (size_t i=0; i<SZ; ++i)
        arr[i] = Rand() % 9;
}

int main()
{    
    int a[5];    
    generateArray(a);
}
18

Sie müssen keinen Zeiger auf das Array nehmen, um es an eine Array-generierende Funktion zu übergeben, da Arrays bereits Verfall auf Zeiger sind, wenn Sie sie an Funktionen übergeben. Machen Sie einfach den Parameter int a[], und verwenden Sie es als reguläres Array innerhalb der Funktion. Die Änderungen werden an dem Array vorgenommen, das Sie übergeben haben.

void generateArray(int a[],  int si) {
    srand(time(0));
    for (int j=0;j<*si;j++)
        a[j]=(0+Rand()%9);
}

int main(){
    const int size=5;
    int a[size];
    generateArray(a, size);
    return 0;
}

Als Randnotiz müssen Sie die Größe nicht als Zeiger übergeben, da Sie sie nicht innerhalb der Funktion ändern. Darüber hinaus ist es keine gute Idee, einen Zeiger auf eine Konstante an einen Parameter zu übergeben, der einen Zeiger auf eine Nichtkonstante erwartet.

6
dasblinkenlight

Ich vermute, das wird helfen.

Wenn Arrays als Funktionsargumente übergeben werden, verhalten sie sich wie Zeiger. Sie müssen sie also nicht referenzieren. Einfach eingeben: int x[] oder int x[a]. Beides wird funktionieren. Konrad Rudolf meinte es wohl genauso, wie ich es mir vorgestellt hatte.

0
Crispin