Quelle est la bonne façon de compenser un pointeur?

Je veux passer un pointeur à une fonction. Je veux que ce pointeur à un endroit au milieu d'un tableau. Dire que j'ai un tableau comme tel unsigned char BufferData[5000];, la déclaration suivante soit correct du point de vue syntaxique?

writeSECTOR( destAddress, (char *)( BufferData + (int)(i * 512 )) );
//destAddress is of type unsigned long
//writeSECTOR prototype: int writeSECTOR ( unsigned long a, char * p );
//i is an int

Oui. Le casting de int est inutile, mais sinon, votre déclaration est valide.
En fait, je dirais que votre solution est meilleure que la plupart des propositions de réponses ci-dessous!
Je préfère le &tableau[i] l'approche la plus évidente que vous êtes à la compensation d'un pointeur vers un tableau, c'est à dire BufferData+(i*512) est moins lisible sur ses intentions, que &BufferData[i*512].
Je suis en désaccord. array + i est beaucoup plus lisible que le &array[i] parce que j'ai lu le dernier "déréférencement de tableau, l'élément i, et de prendre l'adresse" par opposition à la simple "décalage d'adresse i de la matrice". Le problème avec votre favori de la notation, c'est qu'il est de la commutation entre les pointeurs et de référencement dans une déclaration. Alors que le pointeur de plus est juste une pure mathématiques.
Vous n'êtes pas vraiment car le compilateur produira le même code. Mais c'est vraiment une chose subjective. Quand je vois tableau crochets je sais que c'est un pointeur sur un tableau et de réfléchir sur les plages.

OriginalL'auteur PICyourBrain | 2010-10-06

arrays c offset pointers

17

Qui ferait, mais il suffit de faire:
```
 writeSECTOR( destAddress, &BufferData[i * 512]);
```
(Ça sonne comme writeSECTOR devrait vraiment prendre un unsigned char*)

OriginalL'auteur nos
6

Il vous suffit de faire BufferData + i * 512. Une arithmétique + opérateur char* donne un char* lorsque vous ajoutez une valeur entière.

OriginalL'auteur reko_t
5

De l'arithmétique des pointeurs est assez simple à comprendre. Si vous avez un pointeur vers le premier élément d'un tableau alors p + 1 points pour le deuxième élément, et ainsi de suite, indépendamment de la taille de chaque élément. Donc, même si vous aviez un tableau d'entiers, ou une structure arbitraire MyData il serait vrai.
```
MyData data[100];
MyData *p1 = data;;  //same as &data[0]
MyData *p2 = p1 + 1; //same as &data[1]
MyData *p3 = p2 + 1; //same as &data[2]
MyData *p4 = p2 - 1; //same as &data[0] again
```
Si votre tableau est unsigned char, puis il suffit d'ajouter cependant le nombre d'octets décalage vous souhaitez aller dans le tableau, par exemple
```
unsigned char data[16384];
unsigned char *offset = data + 512; //same as &data[512]
*offset = 5; //same as data[512] = 5;
```
Sinon, si la notation est source de confusion, vous pouvez toujours vous référer à elle comme il est indiqué dans les commentaires ci-dessus, par exemple &data[512]

p4 n'est pas " / / &data[1]". p4 est le même que &data[0].

OriginalL'auteur locka
3

Qui devrait fonctionner. En C, l'ajout d'un entier à un pointeur augmente le pointeur par l'entier multiplié par le sizeof le type du pointeur de points.

OriginalL'auteur Nathan Fellman
0

il semble ok, mais l'essayer sur le compilateur,

Vous pouvez utiliser writeSECTOR( destAddress, &BufferData[i * 512] );

OriginalL'auteur Jose
0

Qui dirait qu'il va passer l'adresse de la i*512-ième élément du tableau. Est-ce que vous voulez qu'il fasse?

Je ne vois vraiment pas ce que les cast vers le type int est d'acheter, vous si.

OriginalL'auteur T.E.D.
0

Qui devrait fonctionner comme vous le pensez.
Pointeur en C est juste une adresse dans la mémoire RAM,vous pouvez donc la dérive le pointeur de votre mesure.

OriginalL'auteur shenju

Vous devez vous connecter pour publier un commentaire.