Type en C++

[hexbinmos]

Bonjour.

Étant entrain de voir les pointeurs et ses applications en C++, je me demandais :
Est-ce que "int*" est un type ?

Parce que par exemple, quand je marque "int* p=2" le compilateur dit
error: invalid conversion from 'int' to 'int*'

Si non, qu'est-ce qu'un type ?
Parce que moi, avec les notions que j'ai, je ne fais pas la différence entre une différence de type et une différence entre int* et int.

Voilà, merci =)
-----

[acx01b]

oui int* est un type

int * ptr; // déclaration d'une variable de type int*

ptr = 2; // impossible d'affecter un int à un int*
int k = 2;
ptr = k; // pareil : convertion int vers int* impossible

ptr = (int*)k; // ça marche : tu imposes la convertion int vers int* (int et pointeur sont des nombres, mais comme dans la plupart des cas c'est débile de convertir int en pointeur le compilateur l'interdit, sauf si tu mets un 'cast explicite' c'est à dire la syntaxe que j'ai mise)
k = *ptr; // sauf que 2 est une adresse a priori invalide, donc si tu fais ça tu auras une exception (un segmentation fault)

il faut bien comprendre que c'est complètement différent de ça :

int *ptr;
int k = 2;
ptr = &k; // & opérateur adresse d'une variable
k = *ptr; // parfaitement valide : ptr ne vaut pas 2 mais une 'vraie adresse : l'adresse d'une variable locale'
// c'est *ptr qui vaut 2 et * est l'opérateur d'indirection

enfin en 32bit avec gcc ou visual ceci marche :

int *ptr;
int k = 2;
int kk;
kk = (int)&k; // & opérateur adresse d'une variable, puis (int) opérateur de cast vers int
ptr = (int*)kk; //
k = *ptr;

int********** est aussi un type (pointeur vers int*********)

[bisou10]

int* est en fait une adresse (donc un ulong 32 ou 64 bits) qui s'incrémente/décremente au pas de la taille d'un int (16 bits souvent, voire 32).

[whoami]

Bonjour,

int* est en fait une adresse (donc un ulong 32 ou 64 bits) qui s'incrémente/décremente au pas de la taille d'un int (16 bits souvent, voire 32).

Non, il s'incrémente au pas de la taille d'un pointeur pour le compilateur/options utilisé.

C'était souvent la taille d'un int, mais c'est de moins en moins vrai, en particulier quand on compile pour du 64 bits.

Il faut faire attention à ne pas mélanger les types, même si ça a souvent fonctionné (si tu savais le nombre de bugs dus à ce mélange taille int, taille pointeur..., sans oublier la difficulté qu'ont de nombreux programmeurs pour convertir leurs programmes 32 bits en 64 bits [voir la remarque ci-dessus].

Bref, attention aux confusions.

[A voir en vidéo sur Futura]

[hexbinmos]

Merci beaucoup.
acx01b : Je pense avoir compris ce que tu as dis, mais alors me viens une question similaire pour les alias :
Pourquoi ce code ci ne fait pas un résultat analogue ?

int i = 5;
int q = (int)&i;
int& a = (int&)q;
int* p = (int*)q;
cout << &a << " " << &i << " " << p;

D'après le compilateur int& est un type et il est différent de int*, car il m'a déjà renvoyé cette erreur ci :
error: invalid initialization of non-const reference of type 'int&' from an rvalue of type 'int*'

D'après ce que je comprends, (int)&i passe "&i" du type "int&" au type "int"
(int*)q passe q du type "int" au type "int*".
Le passage du décimal à l’hexadécimal a l'air de bien se faire dans l'affichage du pointeur p à la fin.
Je ne comprends pas pourquoi (int&)q ne passe pas q du type "int" au type "int&". Ou alors si c'est le cas, pourquoi l'alias n'es pas mis en l'adresse (int&)q ?

bisou10

int* est en fait une adresse (donc un ulong 32 ou 64 bits) qui s'incrémente/décremente au pas de la taille d'un int (16 bits souvent, voire 32).

whoami

Non, il s'incrémente au pas de la taille d'un pointeur pour le compilateur/options utilisé.

J'ai essayé de voir si "int*" et "ulong" étaient les mêmes types

    int i=5;
    int* p = &i;
    unsigned long k=p;
    cout << k << " " << p;

error: invalid conversion from 'int*' to 'long unsigned int' [-fpermissive]
Je ne sais pas l'erreur vient du fait que le compilateur avec le "-fpermissive" n'aime simplement pas cette écriture, ou si il y a une différence fondamentale entre un ulong et un int*.
Ou alors ça vient d'une incompatibilité de taille ?

Est-ce que ce que vous dites signifie que le compilateur fait en sorte que la taille d'un int soit la même que celle du int* en fonction du compilateur utilisé ?

[galerien69]

int& a = (int&)q;

Drole de cast.
normalement tu écris
int ref=2;
int &a=ref; //qui signifie a "pointe" vers ref (+ les subtilités de la référence)

(int&)ref comme indiqué par le compilateur c'est équivalent à int* (rvalue).
donc à gauche tu veux du int* a;
De manière générale, néanmoins, tu ne veux pas faire des cast ()var, qui équivaut à du static_cast<>() (en C++), et qui est très souvent signe de problème

Concernant int* et ulong. Ce n'est >pas< les même type.
tu peux par exemple comparer sizeof(int*) avec sizeof(ulong)
Tu peux également tenter de faire une simple assignation
int* a=someUlongValue
ulong a=someIntPtrValue
et voir si le compilateur crie.

Le compilateur ne fait pas en sorte que la taille de l'int* soit de la taille d'un int. C'est agréable parce que un int c'était communément 4 bits, qui était la plus petite entité adressable. Du coup ca valait pas le coup de stocker le pointeur dans un truc diférent vu qu'il doit juste pouvoir pointer sur cette adresse...
Maintenant, faut éviter cette assertion, parce que chaque compilateur est libre de choisir la taille de son pointeur... lire stack
pas de citation excepté le classique sizeof(char) malheureusement..

[hexbinmos]

Je suis au courant de comment déclarer les alias, mais ma question portait sur la situation analogue à celle exprimée avec les pointeurs.
On peut déclarer un pointeur en ne connaissant pas la variable mais simplement son adresse. (ça n'est pas conseillé mais ici je me préoccupe uniquement des possibilités linguistiques).
Je tentais de déclarer un alias avec uniquement l'adresse.

Ici l'adresse est dans q, comme on peut visiblement déclarer un pointeur sur l'adresse q avec int* p = (int*)q
je me demandais comment déclarer un alias avec l'adresse q. Par analogie de types j'ai essayé int& a = (int&)q.
Visiblement les situations de sont pas analogues, comment est-il possible de faire ? ^^



D'accord dont ulong n'est pas le même type que int*.
Après je ne sais ni ce que sont "rvalue", ni "cast ()var" ni "static_cast<>()".
J'irai voir ton lien j'ai pas trop le temps ce matin, je répondrai donc après connaissance des termes. ^^

[bisou10]

Je pense qu'on s'est mal compris.

Un int* n'est pas un unsigned long, en terme de 'typage'. Un int* est un pointeur, donc une adresse, qui est un nombre correspondant a ce que stocke le compilateur, dans son format 'adresse' (c'est des nombre sur 32 ou 64 bits, donc similaires à des ulongs). Mais ce ne sont PAS des ulong au sens 'type'.

int *i;
ulong recup = (ulong)i;
printf("i: %x / recup: %x", i, recup);

Ensuite, le type associé, soit ce qu'il y a écrit avant *, défini la taille des données accédées. Si tu prends un pointeur sur int et que int fait 16 bits sur ta plateforme, tu liras 16 bits et incrémente le pointeur de 1 te donnera les 16 bits suivants.

int *i;
char c[]= "12345678";

i = (int*) &c;
printf("c: %s / contenu de i: 0x%x / contenu de i+1: 0x%x\r\n", c, *i, *(i+1));i
printf("adresse de c: 0x%x / adresse de i: 0x%x\r\n", &c, i);

(pour le code ci-dessus, 0x34 équivaut à '4' donc tu retrouves bien tes chiffres dans i)

[RiketRok]

Salut,

je tente le coup, peut-être que tu comprendras mieux ma façon d'expliquer:
pour une variable

Int a = 5;

a désigne 5
&a désigne son adresse en mémoire (par ex 0x5fa546b)
Et c'est tout.

a + a <=> 5 + 5
&a + a <=> 0x5fa546b + 5
(long int)&a + (char *)a <==> 0x5fa546b + 5
...

Sauf quand le type précède le nom de la variable, le & commercial désigne une référence :
Int & a; (référence sur Int <==> pointeur constant sur int)

Pour ton deuxième problème, comme l'ont indiqué les autres, les pointeurs et références sont généralement codés sur 64 bit alors qu'un Int est codé sur 32 bit:
Int * a : 0b1010101010101010101010101010 1010101
Int b :.. 0b0011001100110011

Si tu fais b = a , vu que b est limité à 32 bits et a en fait 64, tu copie les 32 premiers bits de a dans b :
Int * a : [0b10101010101010101]010101010101010101
int b :. ..[0b10101010101010101]
(la notation est ici inversé, les premiers bits se trouvent à droite généralement)