TABLEAU AVEC ALLOCATION DYNAMIQUE
jonathanmcdougall
Messages postés
64
Date d'inscription
dimanche 9 février 2003
Statut
Membre
Dernière intervention
7 mars 2003
-
3 mars 2003 à 15:00
cs_AmK Messages postés 368 Date d'inscription jeudi 13 mars 2003 Statut Membre Dernière intervention 27 janvier 2010 - 24 mars 2003 à 10:06
cs_AmK Messages postés 368 Date d'inscription jeudi 13 mars 2003 Statut Membre Dernière intervention 27 janvier 2010 - 24 mars 2003 à 10:06
Cette discussion concerne un article du site. Pour la consulter dans son contexte d'origine, cliquez sur le lien ci-dessous.
https://codes-sources.commentcamarche.net/source/10493-tableau-avec-allocation-dynamique
https://codes-sources.commentcamarche.net/source/10493-tableau-avec-allocation-dynamique
24 mars 2003 à 10:06
24 mars 2003 à 10:06
5 mars 2003 à 21:45
>cin>>*(adr+i);
> cout<<"tab["<<j<<"]="<<*(adre+j)<<", ";
c est une consigne qu on m a donné!!!
merci pour le reste!!
5 mars 2003 à 01:47
Déprécié, préferer :
# include
using namespace std;
>void saisie(int,int *);
>void affich(int,int *);
Préférer spécifier le nom des variables pour plus de lisibilité.
> palloc=new int[taille];
> if(palloc==NULL)
> cout<<"
*****Problème d'allocation!!!******
";
La logique est bonne, mais le problème est que new ne retourne pas 0 si l'allocation a échoué, il lance une exception. La façon de le forcer à retourner 0 est de spécifier (nothrow) :
palloc = new (nothrow) int[taille];
Ou tout simplement d'attraper l'exception :
try
{
palloc = new int[taille];
}catch (...)
{
cout << "l'allocation a échoué";
}
> cin>>*(adr+i);
> cout<<"tab["<<j<<"]="<<*(adre+j)<<",
";
Cette syntaxe est à éviter, préférer
cin >> adr[i];
cout<< adre[j];
qui sont beaucoup plus lisibles et sécuritaires.
Finalement, on dirait que tu ne veux pas nommer tes arguments du même nom. Sache que c'est légal :
int f(int mavariable);
int g(int mavariable);
int h(int mavariable);
Les arguments de fonctions différentes peuvent avoir le même nom. Je te recommande ces noms :
void saisie(int taille,int *adresse);
À part ça, tout est bien!
Jonathan
4 mars 2003 à 02:20
Pourquoi tu l'alloues alors que tu vas l'allouer juste après ?
vu que tu fais 2 fois new sur le même pointeur, ya 4 octets qui se sont enfuis...
3 mars 2003 à 16:13
désolé, c'est plutôt
int* allouer(int* adr, int taille);
3 mars 2003 à 15:00
Déprécié, préferer
# include
using namespace std;
>void saisie(int,int);
>void affich(int,int);
Correct, mais il serait meilleur de spécifier le nom des variables, pour une meilleure lisibilité.
>int *palloc = new int;
>int taille;
Variables globales : à éviter. D'ailleurs, tu n'en as pas besoin.
>void main()
int main()
main() retourne *toujours* un int.
>{
> cout<<"Donner la taille du tableau:";
> cin>>taille;
> saisie(taille,*palloc);
> affich(taille,*palloc);
pourquoi passes-tu les tableaux si tu ne t'en sers pas? De plus, l'argument s'appelle 'adr' ou 'adre', pour 'adresse' je suppose, et tu lui passes la valeur de palloc[0] (en lui passant *palloc). De plus, si 'adr' ou 'adre' doivent contenir une adresse, ils devraient être de type int*, non?
> delete[] palloc;
>}
Quelques questions : que se passerait-il en cas d'erreur dans saisie() ou affich()? Par exemple, si saisie() lance une exception?
Ensuite, que se passerait-il si l'utilisateur entrait un nombre négatif? Si 'cin' plantait? Si 'new' manquait de mémoire?
Question de faire aller les méninges un peu :)
>void saisie(int tail,int adr)
>{
Comme j'ai dis plus haut, tu ne te sers pas de 'adr'. Il serait plus avantageux de mettre tes variables globales locales au main() et de les passer en argument dans ces deux fonctions.
> int i;
> palloc=new int[taille];
> for(i=0;i<taille;i++)
Deux choses : il est mieux de définir 'i' dans le for puisque 1) cela améliore la visibilité et 2) cela permet de restreindre la durée de vie de 'i' à la boucle. Deuxièmement, préférer ++i à i++ puisque ce dernier requiert une copie et, donc, plus de temps d'exécution.
> {
> cout<<"saisissez un nombre:";
> cin>>*(palloc+i);
Mauvais. Pourquoi ne pas utiliser palloc[i]?
> }
>}
>void affich(int taile, int adre)
Même chose concernant 'adre'.
>{
> int j;
> for(j=0;j<taille;j++)
Même chose concernant la définition et l'incrémentation de 'j'.
> {
> cout<<"tab["<<j<<"]="<<*(palloc+j)<<",
";
Mauvais aussi, préférer palloc[j].
> }
>}
C'est bon, la seul source de problèmes est l'usage de variables globales. Là où l'on fait
int variable_globale;
void f()
{
std::cout << variable_globale;
}
int main()
{
variable_globale = 20;
f();
}
il faut préférer
void f(int variable_locale)
{
std::cout << variable_locale;
}
int main()
{
int variable_locale = 20;
f(variable_locale);
}
Mais la structure est très intéressante et très efficiente : une fonction, une tâche. Pour ce court programme, c'est très bien, mais il serait encore mieux d'ajouter un
void* allouer(int* adr, int taille);
qui s'occupera du new et en retournera l'adresse. Ainsi, il sera plus facile d'ajouter, par exemple, des tests sur la taille, la création d'objets...
Finalement, il serait bon d'avoir un peu plus de constance dans les noms : 'taile' et 'tail', 'adr' et 'adre'.
Amuses-toi bien!
Jonathan Mcdougall
Montréal, Québec
mcdougalljonathan@hotmail.com
http://www.multimania.com/utopiasoftware