typedef longueur fixe tableau

Je dois définir un 24-bits type de données.Je suis à l'aide de char[3] pour représenter le type. Puis-je typedef char[3] à type24? Je l'ai essayé dans un exemple de code. J'ai mis typedef char[3] type24; dans mon fichier d'en-tête. Le compilateur n'a pas à s'en plaindre. Mais quand j'ai défini une fonction void foo(type24 val) {} dans mon fichier C, il n'a à se plaindre. Je voudrais être en mesure de définir des fonctions comme type24_to_int32(type24 val) au lieu de type24_to_int32(char value[3]).

InformationsquelleAutor 341008 | 2010-12-24

arrays c gcc typedef

278

Le typedef serait
```
typedef char type24[3];
```
Cependant, c'est probablement une très mauvaise idée, parce que le type obtenu est de type tableau, mais les utilisateurs de ne pas voir que c'est un type tableau. Si elle est utilisée comme un argument de fonction, il sera passé par référence et non par valeur, et la sizeof pour il sera alors mal.

Une meilleure solution serait
```
typedef struct type24 { char x[3]; } type24;
```
Probablement, vous voulez aussi être en utilisant unsigned char au lieu de char, puisque ce dernier a la mise en œuvre définie par ce paramètre.
- Est-il un beau document qui décrit le coin des cas impliqués avec le passage typedef ed tableaux comme paramètres? Par exemple, si une fonction prend un paramètre type24 foo, quelles seraient les tailles, les types, et les significations de foo, *foo, **foo, &foo, et &&foo? Ont le sens et la légalité de ces expressions changé au fil des ans?
- Probablement la peine de mentionner la structure de l'emballage de mise en garde, 24-bits type de données peut être destiné à la carte à quelque chose différemment défini par l'emballage de la sémantique comme image RVB en données.
- Sur tous les du monde réel ABIs je suis au courant, même ceux où alignées l'accès est très cher - les structures ne pas obtenir une plus grande harmonisation des exigences de leurs membres auraient sans la structure. Bien sûr OP ou toute autre personne à l'aide de cette approche devrait vérifier ma demande si elle va de la matière à leur programme, du comportement et de la portabilité.
- Existe-il des problèmes lorsque le nom type24 les doublons avant et après { char x[3]; }?
- Pas de. La première est la structure de la balise et le second est le nom du type que vous faites avec typedef.
- J'étais également curieux, j'ai donc fait un exemple où ça se passe mal. Je l'ai posté ci-dessous.
- Une partie de cela est trompeur en C, les tableaux sont toujours passé par référence, c'est à dire, si vous modifiez le tableau passé en argument à une fonction, vous le faites à l'échelle mondiale, non seulement dans le contexte de la fonction. Ceci étant dit, on pourrait aussi affirmer que dans C les tableaux sont toujours être passé par valeur, étant donné que nous avons tout simplement passer l'adresse du premier élément, qui est copié sur la pile lors de l'appel de la pile. Dans les deux cas, cependant, la réponse est trompeuse.
- Malheureusement pour le struct formtation, sizeof(type24) est peu probable d'être 3. Vous aurez probablement besoin d'un peu de compilateur dépendante de bugs. Heureusement, vous pouvez vous assurer que les correctifs sont utilisés avec une judicieuse static_assert.
- Avez-vous vérifié cela? Je suis sûr que c'est 3 sur toutes les cibles intéressantes.
- Il peut être de 3 de vos objectifs. Sans doute vous avez la structure de l'emballage dans votre compilateur? Pas de portable si. Cygwin dit $ cat 1.cpp: struct three { char three[3]; }; static_assert(sizeof(3) == 3, "urk"); et $ g++ -std=c++11 1.cpp donne 1.cpp:2:1: error: static assertion failed: urk static_assert(sizeof(3) == 3, "urk");
- Ce n'est pas l'emballage, il est juste non-insertion gratuite de rembourrage. L'alignement de la structure est le maximum de l'alignement de l'un de ses membres, qui ont tous un alignement 1.
- Votre test est buggé. 3 est un int, et sizeof(int)!=3.
- Oui, vous avez raison! Un struct qui a seulement char membres n'ont aucun rembourrage. Je suis tellement habitué à le compilateur ajout de remplissage pour aligner plus de types que j'ai raté ce cas particulier. Eh bien, vivre et maigre, je suppose. (Oh, j' doit lire mon propre code—je ne voudrais pas m'employer :-).)
InformationsquelleAutor R..
41

Vous voulez
```
typedef char type24[3];
```
C type de déclarations est étrange cette façon. Vous mettez le type exactement où le nom de la variable irait si vous avez été la déclaration d'une variable de ce type.

InformationsquelleAutor ysth

De R..'s réponse:

Cependant, c'est probablement une très mauvaise idée, parce que le type résultant
est de type tableau, mais les utilisateurs de ne pas voir que c'est un type tableau.
Si elle est utilisée comme un argument de fonction, il sera passé par référence, non pas par
valeur, et la sizeof pour il sera alors mal.

Les utilisateurs qui ne voient pas que c'est un tableau sera très probablement écrire quelque chose comme ceci (qui échoue):

#include <stdio.h>

typedef int twoInts[2];

void print(twoInts *twoIntsPtr);
void intermediate (twoInts twoIntsAppearsByValue);

int main () {
    twoInts a;
    a[0] = 0;
    a[1] = 1;
    print(&a);
    intermediate(a);
    return 0;
}
void intermediate(twoInts b) {
    print(&b);
}

void print(twoInts *c){
    printf("%d\n%d\n", (*c)[0], (*c)[1]);
}

De compiler avec les avertissements suivants:

In function ‘intermediate’:
warning: passing argument 1 of ‘print’ from incompatible pointer type [enabled by default]
    print(&b);
     ^
note: expected ‘int (*)[2]’ but argument is of type ‘int **’
    void print(twoInts *twoIntsPtr);
         ^

Et produit la sortie suivante:

InformationsquelleAutor Gerhard Burger

11

Les tableaux peuvent pas être transmis en fonction de paramètres par valeur en C.

Vous pouvez mettre le tableau dans une structure (struct):
```
typedef struct type24 {
    char byte[3];
} type24;
```
et puis passer que par la valeur, mais bien sûr, alors il est moins pratique à utiliser: x.byte[0] au lieu de x[0].

Votre fonction type24_to_int32(char value[3]) passe par pointeur, et non par valeur. C'est exactement équivalente à type24_to_int32(char *value), et la 3 est ignoré.

Si vous êtes heureux de passage par pointeur, vous pourrait coller avec le tableau et faire:
```
type24_to_int32(const type24 *value);
```
Cela va passer un pointeur de tableau, pas de pointeur vers du premier élément, de sorte que vous l'utiliser comme:
```
(*value)[0]
```
Je ne suis pas sûr que ce soit vraiment un gain, car si vous avez accidentellement écrire value[1] alors quelque chose de stupide qui se passe.
- Je pense que cette réponse pourrait être améliorée en mentionnant le terme decay quelque part (et peut-être, en soulignant que la situation est pire pour retour tableaux - ce qui ne fonctionne pas à tous).
InformationsquelleAutor Steve Jessop
11

D'utiliser le type de tableau correctement comme un argument de fonction ou paramètre du modèle, faire une structure au lieu d'une définition de type, puis ajouter une operator[] à la structure de sorte que vous pouvez garder le tableau comme fonctionnalités comme:
```
typedef struct type24 {
  char& operator[](int i) { return byte[i]; }
  char byte[3];
} type24;

type24 x;
x[2] = 'r';
char c = x[2];
```
- C'est une question C, pas du C++. Ni char& ni operator[] sont des choses qui existent dans C.
InformationsquelleAutor Geronimo

Vous devez vous connecter pour publier un commentaire.