indice de pointeur commence à partir de la valeur négative

int nrow=5,ncol=7,i,j; float **ptr; /*allocation*/ ptr=(float **) malloc(nrow*sizeof(float*)); ptr[0]=(float *) malloc(nrow*ncol*sizeof(float)); /*initialize*/ for (i=0;i<nrow;i++) for (j=0;j<ncol;j++) ptr[i][j]=0.0; 

Nous soaps que dans le cas ci-dessus, la ligne commence à 0 et se termine à nrow-1 , la colonne commence à 0 et se termine à ncol-1 . Mais comment puis-je laisser la ligne partir de -4 et se terminer par nrow+3 , ainsi que la colonne de -4 et se terminer par ncol+3 ?

Code supplémentaire:

 #include  #include  float *vector(int nl, int nh){ /* allocate a float vector with subscript range v[nl..nh] and initializing this vector, eg. vector[nl..nh]=0.0 */ float *v; int i,NR_END=0; v=(float *)malloc((size_t) ((nh-nl+1+NR_END)*sizeof(float))); for (i=0;i<(nh-nl+1+NR_END);i++) v[i]=0.0; return v-nl+NR_END; } int main(int argc, char *argv[]) { int i,nrow=5, row1, row2; float *v; row1=-4; row2=nrow+3; v = vector(row1,row2); for (i=-4;i<(nrow+4);i++) { v[i]=(float)i; printf("v[%d]=%f\n",i,v[i]); } exit(0); } 

Si je lance le code ci-dessus, il obtiendra la bonne réponse:

  v[-4]=-4.000000 v[-3]=-3.000000 v[-2]=-2.000000 v[-1]=-1.000000 v[0]=0.000000 v[1]=1.000000 v[2]=2.000000 v[3]=3.000000 v[4]=4.000000 v[5]=5.000000 v[6]=6.000000 v[7]=7.000000 v[8]=8.000000 

À proprement parler, vous ne pouvez pas indexer avant le début ou après la fin d’un tableau. Vous pouvez cependant rendre le tableau plus grand que vous le souhaitez et placer le pointeur de départ quelque part au milieu:

 int nrow = 5, ncol = 5, pre = 4, post = 4; int i,j; float **ptr; ptr = malloc((nrow+pre+post)*sizeof(float*)); for (i=0;i 

Notez que l'allocation pour les colonnes est effectuée une fois pour chaque colonne et non par groupe dans la première colonne. La façon dont vous l'avez eu, rien au-delà de la première colonne ne pointe rien.

Vous pouvez maintenant accéder en toute sécurité aux index de -4 à max + 3.

Nettoyer:

 ptr -= pre; for (i=0;i 

Disons que votre tableau a 7 éléments et est présenté comme suit:

 +-----+-----+-----+-----+-----+-----+-----+ | | | | | | | | +-----+-----+-----+-----+-----+-----+-----+ 

Si un pointeur pointe sur le premier élément du tableau, il peut être indexé comme suit:

 p | v +-----+-----+-----+-----+-----+-----+-----+ | | | | | | | | +-----+-----+-----+-----+-----+-----+-----+ p[0] p[1] p[2] p[3] p[4] p[5] p[6] 

Si un pointeur pointe sur un élément au milieu du tableau, il peut être indexé à l’aide de valeurs négatives.

  p | v +-----+-----+-----+-----+-----+-----+-----+ | | | | | | | | +-----+-----+-----+-----+-----+-----+-----+ p[-3] p[-2] p[-1] p[0] p[1] p[2] p[3] 

Si le pointeur pointe sur un élément après le dernier, il peut être indexé en utilisant uniquement des valeurs négatives.

  p | v +-----+-----+-----+-----+-----+-----+-----+ | | | | | | | | +-----+-----+-----+-----+-----+-----+-----+ p[-7] p[-6] p[-5] p[-4] p[-3] p[-2] p[-1] 

Il n’est pas valable que le pionnier pointe vers quoi que ce soit avant le premier élément. Par conséquent, peu importe où le pointeur pointe dans la plage d’éléments valide, un index valide ne peut pas être inférieur à -7 ni supérieur à 6.

Venir à votre question

Mais comment puis-je laisser la ligne partir de -4 et se terminer par nrow+3 , ainsi que la colonne de -4 et se terminer par ncol+3 ?

Vous ne pouvez pas. Si un pointeur pointe sur le cinquième élément du tableau, vous pouvez utiliser -4 en tant qu’index valide, mais la condition de fin sera nrow-4 / ncol-4 . nrow + / ncol + ne sera jamais le bon index final.

 float** ptr1 = &(5-th row of the array); for ( int i = -4; i < nrow - 4; ++i ) { // OK to use ptr1[i]; float* ptr2 = &(5-the element/column of the row) for ( int j = -4; j < ncol - 4; ++j ) { // OK to use ptr2[j]; } } 

Vous pouvez faire quelque chose comme ceci, mais je ne pense pas que vous puissiez accéder aux colonnes décalées de cette manière, vous devrez indiquer chaque ligne.

 main() { int nrow,ncol; int i,j; float **ptr; float *p; /*allocation*/ nrow=5;ncol=7; ptr=(float **) malloc((nrow+7)*sizeof(float*)); for (i=0; i