avertissement: retour rend pointeur d'entier sans un plâtre, mais renvoie entier comme souhaité

J'essaie de trouver la bonne façon de retourner un entier à partir d'un void * appel de fonction à l'intérieur de C.

ie ..

#include <stdio.h>

void *myfunction() {
 int x = 5;
 return x;
}

int main() {
  printf("%d\n", myfunction());
  return 0;
}

Mais je reçois:

avertissement: retour rend pointeur d'entier sans un casting

Est-il un cast-je faire pour faire ce travail? Il semble de retour x sans problème, le vrai myfunction retours des pointeurs vers des structures et des chaînes de caractères ainsi de tous les travaux comme prévu.

Pourquoi faites-vous cela?
myfunction type de retour est void* mais le type de x est int. Pourquoi voulez-vous le faire fonctionner ? Quelle est la véritable fonction vous travaillez avec ?
Une assez bonne raison: mise à jour du code que quelqu'un d'autre l'a fait.

OriginalL'auteur user2662982 | 2013-08-08

7

Il n'est pas évident ce que vous essayez d'accomplir ici, mais je vais supposer que vous êtes essayer de faire des arithmétique des pointeurs avec x, et aimerais x entier pour cette arithmétique mais un vide pointeur sur le retour. Sans entrer dans pourquoi ce qui fonctionne ou ne pas faire sens, vous pouvez éliminer l'avertissement explicite casting x pour un pointeur void.
```
void *myfunction() {
 int x = 5;
 return (void *)x;
}
```
Ce sera plus susceptible de soulever un autre avertissement, selon la façon dont votre système met en œuvre des pointeurs. Vous pouvez avoir besoin d'utiliser un long au lieu d'un int.
```
void *myfunction() {
 long x = 5;
 return (void *)x;
}
```
Cela ne semble pas faire l'avertissement disparaît, et j'aimerais savoir pourquoi cela fonctionne ou si c'est réellement un comportement indéfini. Chacuns des réponses fait sens pour moi, mais ce n'est exactement ce que je cherchais à faire.
Les autres réponses supposons que vous vouliez retourner un pointeur vers un entier, ce qui est très différent de l'entier comme un pointeur. L'avertissement que vous aviez était de assurez-vous que vous avez réalisé que vous utilisiez un int dans un vide pointeur. Le moulage d'un pointeur sur un long est parfaitement défini, mais il est souvent plus facile de travailler uniquement avec des pointeurs pour éviter la confusion. Comme nulle de l'arithmétique des pointeurs est illégal, pensez à utiliser un char* pointeur, ce qui va se comporter comme un int au cours de l'arithmétique, puisque sa taille est un octet.
Il pourrait être utile de mentionner qu'il pourrait y avoir une plate-forme où un int est plus large puis un void *, de sorte que la conversion de la première à la seconde serait de perdre bits. Donc, si le stockage d'un entier à un pointeur de variable est vraiment nécessaire, on peut envisager de déclarer le nombre entier comme intptr_t x; ou uintptr_t x;, comme intptr_t et uintptr_t sont garantis par le C standard pour s'adapter à un pointeur de variable.
Ce qui est bien définie comportement. Toutefois, elle pourrait perdre bits. Veuillez voir mon commentaire un bove.
Notez que si c'est ce que vous voulez faire, vous pouvez aussi l'écrire comme return (void *) 5;.

OriginalL'auteur user2663103
2

Un void * est un pointeur vers quoi que ce soit, vous avez besoin de retourner une adresse.
```
void * myfunction() {
  int * x = malloc(sizeof(int));
  *x=5;
  return x;
}
```
Cela étant dit, vous ne devriez pas avoir besoin de retourner un void * pour un int, il faut retourner int * ou encore mieux juste int

Je comprends votre intention, mais il n'y a pas de new opérateur dans C.
oups, ce n'était pas prêter attention aux balises
Que ce soit, il peut toujours changer de malloc(sizeof(int)).
il fixe
il fixe, il doit être à l'aide de c++, de toute façon

OriginalL'auteur aaronman
0

Même si vous pensez que la meilleure façon de le faire serait:
```
void *myfunction() {
  int x = 5;
  return &x; //wrong
}
```
c'est en fait un comportement indéterminé, puisque x est alloué sur la pile, et le frame de pile est "roulé" lorsque la fonction retourne. Ce qui est idiot, mais de manière correcte est:
```
void *myfunction() {
  int *x = malloc(sizeof(int));
  *x = 5;
  return x;
}
```
Veuillez ne jamais, jamais écrire du code comme ceci, cependant.

Vous devez trouver un moyen de mettre l'ensemble de la première partie en rouge vif avec un x dessus
Je suis confus, pourquoi est-ce que je peux jeter un entier comme un vide pointeur lors de l'envoi à une autre fonction, mais je ne peux pas jeter un entier comme un vide pointeur lors de la prise comme valeur de retour?
L'entier est stocké sur la pile. Lorsque vous appelez une fonction, la fonction d'origine du "stack frame" (de stockage pour les variables) est préservée, et la nouvelle fonction obtient l'espace "en haut" de l'ancien bloc de pile. Cependant, une fois que la fonction retourne, il n'y a aucune garantie que les variables seront préservés, puisque l'espace "en haut" pourrait être utilisé pour d'autres variables. Vous voudrez peut-être lire sur le pile et segment pour plus de détails.
dans le premier code que vous retourner l'adresse d'une variable locale provoque un comportement indéterminé au moment de l'exécution.
Ce n'est pas "stupide", c'est l'intention d'utiliser une void* retour. Ce qui pourrait être idiot, c'est de revenir à seulement un unique entier au lieu d'une structure. Ce type de fonction est souvent utilisée dans le cadre d'un rappel de sorte que l'utilisateur de rappel peut retourner un pointeur de données.

OriginalL'auteur 1''

J'ai compilé cette source avec gcc -pedantic:

 #include <stdio.h>

 void *myfunction() {
   size_t x = 5;  
   return (void*)x;
 }

 int main() {
   printf("%d\n", *(int*)myfunction());
   return 0;
 }

Il n'y a pas de mises en garde

OriginalL'auteur Valeriy

Vous devez vous connecter pour publier un commentaire.