Comment voulez-vous déplacer le premier indice d'un tableau en C?

Je suis en train de basculer l'indice de départ d'un tableau d'entiers en C. Pour être précis, j'ai le tableau suivant:

{ int array[4] = {1,2,3,4};}

Je souhaite changer {array} pour un tableau de 3 éléments contenant {2,3,4}. Je me demandais si il y avait un moyen facile de faire cela en utilisant les pointeurs et sans se déplacer tous les éléments dans le tableau. Je suis également heureux si {array} reste un tableau de 4 éléments, tant que les 3 premiers articles sont {2,3,4}. J'ai essayé le suivant:

{array = &(array[1])}

Toutefois, cela ne fonctionne pas et je reçois un message d'erreur indiquant {types incompatibles lors de l'affectation de type ‘int[4]’ from type ‘int *’}.

J'étais sous l'impression que C tableau est une référence au premier élément du tableau.

Quelqu'un peut-il m'aider?

Cette impression est une idée fausse, qui est encore, à tort, considérée comme "plus intuitive" et donc encore enseigné. Il mord souvent un à l'arrière, tôt ou tard.
Un nom de tableau est un constant qui décrit l'ensemble du bloc de mémoire alloué pour cette matrice. Il ne peut jamais être attribué. Lorsqu'il est utilisé comme un valeur, il est automatiquement converti en un pointeur vers le premier élément, à travers lequel les éléments du tableau peuvent être consultés et modifiés.
Un nom de tableau est une expression de type tableau. Il peut être implicitement converti en une valeur de type pointeur dans certains contextes,. Les Expressions de type tableau sont tout simplement pas programmable en C, pas seulement des tableaux de noms.

OriginalL'auteur Dieter | 2013-10-31

  1. 10

    Vous avez un peu d'options:

    Déplacer tous les éléments à gauche par un

    Si la conservation du contenu ne sont pas nécessaires:

    int array[4] = { 1, 2, 3, 4 };

    puis vous copier/déplacer les éléments de l'index de la position n à la position d'index n-1:

    Par exemple:

    int i;
for (i = 1; i < n; ++i)
  array[i-1] = array[i];

    Vous pouvez aussi regarder memmove qui pourrait être plus efficace.

    Par exemple,

    memmove(array, array+1, sizeof array - sizeof *array);

    qui fait la même chose que la boucle ci-dessus.

    Copier des éléments dans une nouvelle matrice ignorant la première

    Si la conservation des données d'origine est nécessaire, alors vous pouvez créer un autre tableau et copier les éléments que le fait d'ignorer le premier élément.

    Par exemple,

    int array1[4] = { 1, 2, 3, 4 };
int array2[3];
int i;

for (i = 0, i < SIZE_OF_SMALLER_ARRAY; ++i)
  array2[i] = array1[i+1]

    Utiliser un pointeur pour se référer à tableau[1], tableau[0]

    Si vous souhaitez utiliser le pointeur en éliminant la nécessité de déplacer/copier des données:

    int array[4] = { 1, 2, 3, 4 };
int *pArray = &array[1];

    Maintenant pArray points pour le deuxième élément dans le tableau de manière efficace vous permettant d'indice de tableau[1] comme pArray[0]

    Utiliser un tableau de pointeurs int 

    int array[4] = { 1, 2, 3, 4 };
int *parray[3];

int i;
for (i = 0; i < SIZE_OF_SMALLER_ARRAY; ++i)
  parray[i] = &array[i+1];

    Mises en garde

    Une chose que vous ne pouvez pas faire, c'est...

    int array1[4] = { 1, 2, 3, 4 };
array1 = &array1[1]; //!! Compiler Error !!

    La raison en est array1 est un non-modifiable l-value. Essentiellement une constante.

    Vous aussi vous ne pouvez pas faire cela...

    int array1[4] = { 1, 2, 3, 4 };
int array2[4] = array[1] //!! Compiler error !!

    La raison ici est que vous ne pouvez pas initialiser un tableau dans ce contexte.

    Une chose à noter est que, étant donné int array[4], vous pouvez utiliser sizeof pour obtenir la taille de la matrice, et donc le nombre d'éléments (sizeof array / sizeof array[0]). La plupart de ces solutions (qui sont parfaitement valables) ne vous donne pas quelque chose que vous pouvez appliquer de façon significative sizeof.

    OriginalL'auteur ffhaddad

  2. 1

    Vous pouvez le faire, p points à l'intérieur de l'original array. array est inchangé.

    #include <stdio.h>

int main(void) {
        int array[4] = {1,2,3,4};
        int *p = array + 1;
        printf("%d %d %d\n", p[0], p[1], p[2]);
        return 0;
}

    imprime "2 3 4"

    Vous pouvez passer un tableau à l'aide memmove, mais il ne déplacer tous les bits.
    Les tableaux peuvent être copiés avec memcopy, de nouveau, les bits sont copiées.

    Comme indiqué ci-dessus pointeurs permettent de vous déplacer dans le tableau.

    OriginalL'auteur Charlie Burns

  3. 0

    Vous ne pouvez pas 'shrink' ou 'étendre' ie. changer la taille de la matrice créée de cette façon en C/C++.

    Ce que vous devriez regarder dans dynamiquement l'allocation de la mémoire avec lequel vous pouvez faire des choses comme ça.

    OriginalL'auteur Artur