[c++]Créer dynamiquement des int
Salut. Je vous expose mon problème : je souhaite faire une fonction qui permet de créer de façon dynamique des variables (par exemple des int), de leur donner un nom et une valeur. Par exemple essayons de créer a=5, b=6 et c=7. Est-ce que le code suivant est correct?
#include<stdio.h>
#include<stdlib.h>
void creerint(int *ptr2)
{
printf("Nom de la variable?");
scanf("%s", ptr2);
printf("Valeur de la variable créée?");
scanf("%d", *ptr2);
}
main()
{
int *ptr1=NULL;
ptr1=malloc(sizeof(int));
creerint(ptr1);
}
Remarque : je voudrais utiliser un malloc et non pas un new comme vous allez certainement me le conseiller ;-)
Par avance merci de votre réponse.
#include<stdio.h>
#include<stdlib.h>
void creerint(int *ptr2)
{
printf("Nom de la variable?");
scanf("%s", ptr2);
printf("Valeur de la variable créée?");
scanf("%d", *ptr2);
}
main()
{
int *ptr1=NULL;
ptr1=malloc(sizeof(int));
creerint(ptr1);
}
Remarque : je voudrais utiliser un malloc et non pas un new comme vous allez certainement me le conseiller ;-)
Par avance merci de votre réponse.
A voir également:
- [c++]Créer dynamiquement des int
- Créer un lien pour partager des photos - Guide
- Comment créer un groupe whatsapp - Guide
- Créer un compte google - Guide
- Créer un compte gmail - Guide
- Créer un compte instagram sur google - Guide
1 réponse
Ben là c'est plus du C que du C++ :-) (new | malloc; << | scanf; >> | printf).
Accessoirement un main est sensé retourner un int (le code d'exécution, 0 si tout va bien).
Rappels sur les pointeurs
Bon ensuite manifestement tu n'as pas très bien compris comment marchait un poiteur. Pas de problème on est tous passés par là moi la première :-) Alors mettons les choses au clair, un pointeur c'est une adresse et rien d'autre (ça prend donc en mémoire la taille d'une adresse). Et ça peut être l'adresse mémoire de n'importe quoi (un int, un char un struct plop...), sauf qu'en général on type le pointeur pour décrire ce qui se trouve à cette adresse. Par exemple, si c'est l'adresse d'un struct plop, le type c'est plop *. Ca peut être l'adresse d'un pointeur (par exemple un int ** c'est un pointeur sur un int* qui lui même pointe sur un int.
Le truc c'est qu'un pointeur n'a initialement pas une adresse valide, il faut donc l'initialiser :
- soit à partir d'un objet déjà existant en mémoire : par exemple :
- soit en allouant une plage mémoire et en le faisant pointer dessus :
Ne pas oublier que à chaque malloc est associé un free utilisé pour désallouer la plage mémoire une fois que celle-ci devient inutile.
Rappel 2 : les tableaux
En C les "tableaux" sont des plages de n objets contigus d'un type donnés. En particulier :
Le problème des allocations statiques c'est que tu dois connaître à la compilation le nombre de cases que tu vas utiliser (ici 5) et ce n'est pas toujours possible, surtout si tu veux éviter de surallouer.
C'est là que les pointeurs entrent en jeux :
A noter que l'on est obligé de bien faire le free(tab) car sinon on désalloue juste l'adresse, mais pas ce qui se trouve à cette adresse !!!!
Retour sur ton code
Ici il faut bien veiller à mettre un char ** pour pstr car tu vas écrire une chaîne de caractère. Tu ne peux pas stocker le nom de la variable de cette façon, il faut faire une structure qui encapsule le nom et la valeur.
Bon ça c'est pour la version C, mais c'est quand même bien plus simple de faire du bon vieux C++ :
Bonne chance
Accessoirement un main est sensé retourner un int (le code d'exécution, 0 si tout va bien).
Rappels sur les pointeurs
Bon ensuite manifestement tu n'as pas très bien compris comment marchait un poiteur. Pas de problème on est tous passés par là moi la première :-) Alors mettons les choses au clair, un pointeur c'est une adresse et rien d'autre (ça prend donc en mémoire la taille d'une adresse). Et ça peut être l'adresse mémoire de n'importe quoi (un int, un char un struct plop...), sauf qu'en général on type le pointeur pour décrire ce qui se trouve à cette adresse. Par exemple, si c'est l'adresse d'un struct plop, le type c'est plop *. Ca peut être l'adresse d'un pointeur (par exemple un int ** c'est un pointeur sur un int* qui lui même pointe sur un int.
Le truc c'est qu'un pointeur n'a initialement pas une adresse valide, il faut donc l'initialiser :
- soit à partir d'un objet déjà existant en mémoire : par exemple :
int x; int *px = &x;
- soit en allouant une plage mémoire et en le faisant pointer dessus :
int *px = (int *)malloc(sizeof(int)); // je pointe sur un entier int *px5 = (int *)malloc(5*sizeof(int)); // je pointe sur une plage de 5 entiers
Ne pas oublier que à chaque malloc est associé un free utilisé pour désallouer la plage mémoire une fois que celle-ci devient inutile.
free(px); free(*px5);
Rappel 2 : les tableaux
En C les "tableaux" sont des plages de n objets contigus d'un type donnés. En particulier :
{
int tab[5]; //allocation statique d'un tableau de 5 int. variable locale
tab[0] = 6; // tab[0] == *tab
tab[1] = 2;
tab[2] = 9; // affecte l'entier situé "deux int" après tab[0]
tab[3] = 3;
tab[4] = 6;
} // désallocation des variables locales, ie la variable tab
Le problème des allocations statiques c'est que tu dois connaître à la compilation le nombre de cases que tu vas utiliser (ici 5) et ce n'est pas toujours possible, surtout si tu veux éviter de surallouer.
C'est là que les pointeurs entrent en jeux :
{
int *tab =(int *)malloc(n*sizeof(int)); //allocation dynamique de n int.
for(i=0;i<n;++i) tab[i] = 69*i;
//...
free(tab);
} // désallocation des variables locales, ie la variable tab
A noter que l'on est obligé de bien faire le free(tab) car sinon on désalloue juste l'adresse, mais pas ce qui se trouve à cette adresse !!!!
Retour sur ton code
printf("Nom de la variable?");
scanf("%s",pstr);
Ici il faut bien veiller à mettre un char ** pour pstr car tu vas écrire une chaîne de caractère. Tu ne peux pas stocker le nom de la variable de cette façon, il faut faire une structure qui encapsule le nom et la valeur.
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct variable{
char *nom;
int valeur;
} variable_t;
variable_t new_variable(const char *nom0,const int valeur0){
variable_t v;
v.nom = (char *)malloc((strlen(nom0)+1)*sizeof(char));
strcpy(v.nom,nom0);
v.valeur = valeur0;
return v;
}
void delete_variable(variable_t v){
free(v.nom);
}
void show_variable(const variable_t v){
printf("nom = %s\n",v.nom);
printf("val = %d\n",v.valeur);
}
int main(){
unsigned int i;
int x;
char *buffer = (char*)malloc(255*sizeof(char));
for(i=0;i<5;++i){
printf("nom variable ?\n");
scanf("%s",buffer);
printf("valeur variable ?\n");
scanf("%d",&x);
variable_t v = new_variable(buffer,x);
show_variable(v);
delete_variable(v);
}
free(buffer);
return 0;
}
Bon ça c'est pour la version C, mais c'est quand même bien plus simple de faire du bon vieux C++ :
#include <string>
#include <iostream>
typedef struct variable{
std::string nom;
int valeur;
} variable_t;
variable_t new_variable(const char *nom0,const int valeur0){
variable_t v;
v.nom = nom0;
v.valeur = valeur0;
return v;
}
void show_variable(const variable_t & v){
std::cout << "nom = " << v.nom << std::endl;
std::cout << "val = " << v.valeur << std::endl;
}
int main(){
for(unsigned int i=0;i<5;++i){
int x;
std::string buffer;
std::cout << "nom variable ?" << std::endl;
std::cin >> buffer;
std::cout << "valeur variable ?" << std::endl;
std::cin >> x;
variable_t v = new_variable(buffer.c_str(),x);
show_variable(v);
}
return 0;
}
Bonne chance