Quel est le type de cette variable? (C -> C++ )

Je cherche à convertir ça en C++:

Code:

---

int *neigh = (int *)malloc(n * sizeof(int)), nn;

---

Je vois bien qu'il y a un std::vector<int> neigh(n);, mais je ne comprends pas ce que fait le nn, ni quel est son type. Ca ressemble à un integer, parce que dans la suite du code, on trouve des choses comme:

• nn = 0;
• if(j< nn)
• nn++

Citation:

---

Envoyé par Seabirds

Ca ressemble à un integer

---

C'est la base du C :mrgreen: la variable nn est de type int.

On utilise l'opérateur virgule pour chaîner les définitions des variables exemple : int x, y, z;.
Mais dans 1 définition est inclus l'initialisation int x=25, y, z=82;.

Les variables pointeurs sont assez "vicieuses" parce que l'étoile n'affecte que la variable concernée, mais le type affecte toute la chaîne des définitions.
C'est pour cela que certains préfèrent "coller" l'étoile à la variable concernée (int *x;) et non au type (int* x;).

Vu que c'est assigné à un int*, nn est forcément un int*.
Quant au code, il est juste immonde et génère rien d'autre qu'une fuite mémoire. :weird:

Aaaah bah décidez-vous les copains! int ou int* ? :D
Oui oui, on est bien d'accord, c'est pas du joli code ahahah. Mais je fait le ménage et propage la bonne parole du C++ moderne, t'en fais pas :mrgreen:

Ce seul code est ambigu sans contexte.
Soit c'est l'opérateur , donc tout est exécuté et seule la dernière valeur est assignée, donc ça fait le malloc, puis assign nn, donc nn doit être un int* précédemment déclaré, et le malloc est une fuite mémoire.
Soit la, est juste un délimiteur et c'est une déclaration de neigh comme int* auquel on assigne le malloc et la déclaration de nn comme int non initialisé.

Citation:

---

Code:

---

1 2 3

nn = 0; if(j< nn) nn++

---

---

Rien de tout ça n'est interdit sur des pointeurs.

Oh mon dieu, mais c'est vraiment vraiment immonde alors!
Donc de ce que je vois du code, nn n'a jamais été déclarée (ni vers un int, ni vers un *int. Donc c'est ta deuxième option qui l'emporte.
C'est vrai que ça coute super cher en encre de taper int nn = 0; !:mouarf:

Citation:

---

Envoyé par Seabirds

C'est vrai que ça coute super cher en encre de taper int nn = 0; !:mouarf:

---

C'est 1 peu stupide ce que tu dis :koi:

Chaîner les définitions cela permet de réduire la taille des blocs des définitions. Alors certes en C++, on peut définir 1 variable n'importe quand.
Mais ce n'est pas le cas avant le C99 qui oblige de définir en début de bloc.

Après définir 1 pointeur et 1 variable normale en même temps, ce n'est pas vraiment approprié (parce qu'en définitive ce n'est pas le même type).
En tout cas, ton debugger/ compilateur (avec 1 printf par exemple) devrait te dire les types.

Bonsoir,

Comme dit par foetus, nn n'est pas un pointeur, il s'agit d'un int. L'étoile ne s'applique en effet qu'à la seule variable qui suit. Et cette variable nn est bel et bien déclarée sur cette ligne.
Ton code est équivalent à :

Code:

---

1 2	int *neigh = (int *)malloc(n * sizeof(int)); int nn;

---

Si tu as d'autres interrogations dans le même genre, je peux te conseiller l'excellent site https://cppinsights.io/.

Oui c'est une blague un peu stupide ;)
Je sais bien qu'il y a tout un tas de pratiques qui font du sens en C - et je suis sûr que du joli C ça doit être bien sympa à travailler :) Mais dans ce cas précis, le code n'en est vraiment pas à la déclaration chaînée près :?
Dans mon cas, lire le code de Winjerome m'aurait été plus clair :) Aussi merci pour le site! C'est la première fois que je me frotte à du C et c'est plein de syntaxe inconnue :)

C'est 1 spécificité du language C (l'étoile dans 1 définition) ... que ceux qui font les tests pour les entretiens l'utilisent (pour faire des tests vite fait).
Par exemple : int* a, b, *c, **d, e; Quel est le type de c et de e ? :mrgreen:

En C++, c'est + la place du const :

Code:

---

1 2 3 4 5

size_t i;   const size_t * a; size_t const * b; size_t * const c = &i;

---

C'est soit le pointeur soit le pointé qui est constant.


@Bousk parle de l'opérateur virgule qui a 2 fonctions : comme séparateur ou comme opérateur.
comma operator, lien wikipedia en anglais

L'operateur virgule est surtout utilisé dans la boucle for pour les initialisations et pour les instructions de boucle.
On peut arriver a du code assez "brutal" :mrgreen:

Code:

---

1 2 3 4 5 6 7

size_t i,j;   for(i=1, j=11; i < 10; printf("%lu\n", 2*i+j), j=j-1, ++i);   printf("\n****\n");   for(i=1, j=11; i < 10; i=(printf("%lu\n", 2*i+j), j=j-1, i+1));

---

c serait donc un pointeur sur integer, et e un simple integer :D Ok, une fois qu'on connait le truc c'est facile, mais faut le connaître. Va peut etre falloir que je me décide à lire un cours de C un de ces jours ... :calim2:

Daaamn, j'avais jamais pensé au double usage de la virgule :oops: Cet extrait de code est remarquablement obscure ahaha Il a fallu que j'utilise compiler explorer pour avoir l'output. Diantre! :aie:

Salut,

Citation:

---

Envoyé par foetus

C'est 1 peu stupide ce que tu dis :koi:

Chaîner les définitions cela permet de réduire la taille des blocs des définitions. Alors certes en C++, on peut définir 1 variable n'importe quand.
Mais ce n'est pas le cas avant le C99 qui oblige de définir en début de bloc.

---

Ouais, mais bon...

D'abord, je ne suis quand meme pas sur de préférer avoir une ligne par variable, même si elles sont toutes déclarées en début de bloc, avec le types correspondants pour chacune, car cela provoque une moins grande "charge cognitive"

Et, ensuite, je doute très fort que, même avant 1999, le fait d'avoir trois fois le terme int dans un code au lieu de ne l'avoir une fois ait risqué d'occasionner le moindre problème en terme de taille du fichier sur le disque dur, même lorsque la taille des disques durs s'exprimait encore en Mb :D

Il n'y a vraiment que si on remonte vraiment très loin, presque à l'époque où C a été créé, que chaque caractère pouvait effectivement compter dans le code ;)