C tiefgestellte Wert ist weder array nor pointer nor vector bei der Zuweisung eines array-Elements mit dem Wert

Sorry für die Fragen, die bereits beantwortet Frage, ich bin ein Neuling auf C und nicht verstehen, die Lösungen.
Hier ist meine Funktion

int rotateArr(int *arr) {
    int D[4][4];
    int i = 0, n =0;
    for(i; i < M; i ++ ){
        for(n; n < N; n++){
            D[i][n] = arr[n][M - i + 1];
        }
    }
    return D;
}

Wirft es einen Fehler

main.c|23|Fehler: tiefgestellte Wert ist weder array noch
pointer nor vector|

on line

D[i][n] = arr[n][M - i + 1];

Was ist falsch? Ich bin nur der Wert von einem array-element einem anderen array-element.

Arr bestanden erklärt wird

int S[4][4] = { { 1, 4, 10, 3 }, { 0, 6, 3, 8 }, { 7, 10 ,8, 5 },  { 9, 5, 11, 2}  };

Vielleicht haben Sie gedacht, zu schreiben int rotateArr(int **arr)?
so wie es scheint!

InformationsquelleAutor Euphe | 2013-11-11

arrays c

C können Sie den subskript-operator [] auf arrays und Zeiger. Wenn Sie diesen operator auf einen Zeiger, der entstehende Typ ist der Typ, auf den der Zeiger zeigt. Zum Beispiel, wenn Sie sich bewerben [] zu int* werden, wäre das Ergebnis ein int.

Genau das ist, was Los ist: Sie sind vorbei int*, das entspricht einem Vektor von Integer-zahlen. Mit Tiefgestellt es auf einmal macht es int, so dass Sie anwenden können, das zweite subskript zu.

Scheint es aus dem code, dass arr sollte ein 2-D array. Wenn es umgesetzt wird, wie eine "gezackte" array (also ein array von Zeigern), dann ist der parameter-Typ sollte int **.

Zudem scheint es, dass Sie versuchen, um return ein lokales array. Um dies zu tun, legal ist, müssen Sie zuweisen, das array dynamisch, und gibt einen Zeiger. Aber ein besserer Ansatz wäre die Deklaration einer speziellen struct für Ihre 4x4-matrix, und es verwenden, um wickeln Sie Ihre array fester Größe, wie das ist:

//This type wraps your 4x4 matrix
typedef struct {
    int arr[4][4];
} FourByFour;
//Now rotate(m) can use FourByFour as a type
FourByFour rotate(FourByFour m) {
    FourByFour D;
    for(int i = 0; i < 4; i ++ ){
        for(int n = 0; n < 4; n++){
            D.arr[i][n] = m.arr[n][3 - i];
        }
    }
    return D;
}
//Here is a demo of your rotate(m) in action:
int main(void) {
    FourByFour S = {.arr = {
        { 1, 4, 10, 3 },
        { 0, 6, 3, 8 },
        { 7, 10 ,8, 5 },
        { 9, 5, 11, 2}
    } };
    FourByFour r = rotate(S);
    for(int i=0; i < 4; i ++ ){
        for(int n=0; n < 4; n++){
            printf("%d ", r.arr[i][n]);
        }
        printf("\n");
    }
    return 0;
}

Diese druckt die folgenden:

InformationsquelleAutor dasblinkenlight

6

Außer, wenn es ist der operand der sizeof oder unäre & Betreiber, oder ein string-literal verwendet wird, zu initialisieren ein array in einer Erklärung, die einen Ausdruck vom Typ "N-element array von T" umgewandelt ("zerfällt") in einen Ausdruck vom Typ "Zeiger auf T", und der Wert des Ausdrucks ist Adresse des ersten Elements des Arrays.

Wenn die Deklaration des Arrays übergeben werden
```
int S[4][4] = {...};
```
dann, wenn Sie schreiben
```
rotateArr( S );
```
den Ausdruck S Typ "4-element-array von 4-element-array von int"; seit S ist nicht der operand der sizeof oder unäre & Betreiber, wird es konvertiert werden, ein Ausdruck vom Typ "Zeiger auf 4-element-array von int", oder int (*)[4], und diese Zeiger Wert ist, was wirklich übergeben bekommt, um rotateArr. Damit Sie Ihre Funktion Prototyp muss eine der folgenden sein:
```
T rotateArr( int (*arr)[4] )
```
oder
```
T rotateArr( int arr[][4] )
```
oder sogar
```
T rotateArr( int arr[4][4] )
```
In den Kontext einer Funktion parameter-Liste von Deklarationen der form T a[N] und T a[] interpretiert werden als T *a; alle drei erklären a als Zeiger auf T.

Sind Sie wahrscheinlich Fragen, warum ich änderte den Rückgabetyp von int zu T. Wie geschrieben, du versuchst auf einen Rückgabewert des Typs "4-element-array von 4-element-array von int"; leider können Sie nicht tun. C-Funktionen nicht Rückgabe-array-Typen, noch können Sie zuweisen, array-Typen. Anders ausgedrückt, Sie können nicht schreiben, so etwas wie:
```
int a[N], b[N];
...
b = a; //not allowed
a = f(); //not allowed either
```
Funktionen zurückgeben kann Zeiger auf arrays, aber das ist nicht das, was Sie hier wollen. D wird aufhören zu existieren, sobald die Funktion gibt, so dass alle Zeiger kehren Sie ungültig.

Wenn Sie möchten, weisen Sie die Ergebnisse des gedrehten Arrays in ein anderes array, dann müssen Sie passieren die Ziel-array als parameter an die Funktion:
```
void rotateArr( int (*dst)[4], int (*src)[4] )
{
  ...
  dst[i][n] = src[n][M - i + 1];
  ...
}
```
Und rufen Sie es als
```
int S[4][4] = {...};
int D[4][4];

rotateArr( D, S );
```
- Schöne Erklärung!
InformationsquelleAutor John Bode
6

Sind Sie nicht, indem Sie Ihre 2D-array korrekt. Dies sollte für Sie arbeiten
```
int rotateArr(int *arr[])
```
oder
```
int rotateArr(int **arr) 
```
oder
```
int rotateArr(int arr[][N]) 
```
Anstelle der Rückgabe der array-pass das Ziel-array als argument. Siehe Johannes Bode Antwort.
- was ist die richtige Rückgabetyp?
- Dank bearbeitet.
- int ** und int [][N] sind nicht gleichwertig.
- Auch mit einer Besetzung (int **)S, int ** ist nicht in der Lage zu repräsentieren int[4][4], und (int *arr[]) muss (int (*arr)[4])
- Acme, siehe die Antwort von John Bode
- Danke, habe den Punkt:)
InformationsquelleAutor Sadique
3

Das problem ist, dass arr ist nicht (erklärt) ein 2D-array, und Sie behandeln es, als wäre es 2D.
- Was ist der richtige Weg, es zu erklären?
- Siehe meine Antwort.
InformationsquelleAutor NPE
0

Müssen Sie "int* arr" so "arr[n]" ist ein int, richtig? Dann ist dein "[M - 1 + 1]" etwas ist, versucht, dass int als array/- Zeiger/Vektor.

InformationsquelleAutor Peter Cardona
0

das zweite subskript-operator ist hier ungültig.
Übergeben wird ein int * Zeiger auf Funktion, die ein 1-d array. Also nur ein subskript-operator kann es verwendet werden.

Lösung : Sie können den pass int ** Zeiger in funciton

InformationsquelleAutor nathan

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.