C-subscriptwaarde is noch array, noch pointer, noch vector bij het toewijzen van een array-elementwaarde

Sorry voor het stellen van de reeds beantwoorde vraag, ik ben een beginner in C en begrijp de oplossingen niet.
Hier is mijn functie

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;
}

Er wordt een fout gegenereerd

main.c|23|error: gesubscripte waarde is noch array noch
aanwijzer noch vector|

online

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

Wat is er aan de hand? Ik stel alleen de waarde van een array-element in op een ander array-element.

De doorgegeven arr wordt gedeclareerd als

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

Antwoord 1, autoriteit 100%

C laat je de subscript-operator [] gebruiken op arrays en op pointers. Wanneer u deze operator op een aanwijzer gebruikt, is het resulterende type het type waarnaar de aanwijzer verwijst. Als u bijvoorbeeld [] toepast op int*, zou het resultaat een int zijn.

Dat is precies wat er aan de hand is: je geeft int* door, wat overeenkomt met een vector van gehele getallen. Als je er eenmaal subscript op gebruikt, wordt het int, dus je kunt het tweede subscript er niet op toepassen.

Uit uw code blijkt dat arr een 2D-array moet zijn. Als het is geïmplementeerd als een “gekartelde” array (d.w.z. een array van pointers), dan moet het parametertype int ** zijn.

Bovendien lijkt het erop dat u een lokale array probeert te retourneren. Om dat legaal te doen, moet u de array dynamisch toewijzen en een aanwijzer retourneren. Een betere benadering zou echter zijn om een ​​speciale struct voor uw 4×4-matrix te declareren en deze te gebruiken om uw array met vaste grootte in te pakken, zoals deze:

// 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;
}

Deze drukt het volgende af:

3 8 5 2 
10 3 8 11 
4 6 10 5 
1 0 7 9 

Antwoord 2, autoriteit 32%

U geeft uw 2D-array niet correct door. Dit zou voor jou moeten werken

int rotateArr(int *arr[])

of

int rotateArr(int **arr) 

of

int rotateArr(int arr[][N]) 

In plaats van de array terug te geven, geef je de doelarray door als argument. Zie het antwoord van John Bode.

Antwoord 3, autoriteit 24%

Behalve wanneer het de operand is van de sizeof of unaire & operator, of een letterlijke tekenreeks wordt gebruikt om een ​​andere array in een declaratie te initialiseren, een uitdrukking van type “N-element array van T” wordt geconverteerd (“decays”) naar een uitdrukking van het type “pointer to T“, en de waarde van de uitdrukking is het adres van het eerste element van de array.

Als de declaratie van de array die wordt doorgegeven is

int S[4][4] = {...};

dan wanneer je schrijft

rotateArr( S );

de uitdrukking S heeft het type “4-element array of 4-element array of int“; aangezien S niet de operand is van de operatoren sizeof of unaire &, wordt het geconverteerd naar een uitdrukking van het type “pointer to 4- elementarray van int“, of int (*)[4], en deze pointer-waarde is wat daadwerkelijk wordt doorgegeven aan rotateArr. Dus uw functie-prototype moet een van de volgende zijn:

T rotateArr( int (*arr)[4] )

of

T rotateArr( int arr[][4] )

of zelfs

T rotateArr( int arr[4][4] )

In de context van een functieparameterlijst worden declaraties van de vorm T a[N] en T a[] geïnterpreteerd als T *a; alle drie verklaren a als een verwijzing naar T.

Je vraagt ​​je waarschijnlijk af waarom ik het retourtype heb gewijzigd van int in T. Zoals geschreven, probeer je een waarde van het type “4-element array of 4-element array of int” te retourneren; helaas kun je dat niet doen. C-functies kunnen geen arraytypes retourneren, en u kunt ook geen arraytypes toewijzen. IOW, je kunt niet zoiets schrijven als:

int a[N], b[N];
...
b = a; // not allowed
a = f(); // not allowed either

Functies kunnen pointers teruggeven aan arrays, maar dat is niet wat je hier wilt. D houdt op te bestaan ​​zodra de functie terugkeert, dus elke aanwijzer die u teruggeeft, is ongeldig.

Als je de resultaten van de geroteerde array aan een andere array wilt toewijzen, dan moet je de doelarray als parameter doorgeven aan de functie:

void rotateArr( int (*dst)[4], int (*src)[4] )
{
  ...
  dst[i][n] = src[n][M - i + 1];
  ...
}

En noem het zo

int S[4][4] = {...};
int D[4][4];
rotateArr( D, S );

Antwoord 4, autoriteit 12%

Het probleem is dat arr niet (verklaard als) een 2D-array is en dat u het behandelt alsof het 2D is.

Antwoord 5

Je hebt “int* arr” dus “arr[n]” is een int, toch? Dan probeert je “[M – 1 + 1]” bit die int te gebruiken als een array/pointer/vector.

Antwoord 6

de tweede subscript-operator is hier ongeldig.
Je hebt een int * pointer doorgegeven aan functie, wat een 1-d array is. Er kan dus maar één subscript-operator op worden gebruikt.

Oplossing: u kunt de int **-aanwijzer doorgeven aan de functie