pouvez vous me dire quel est le probleme avec ca:

1. include <stdio.h>
2. include <stdlib.h>

int main(int argc, char *argv[])
{
long age=2;

switch(age)
{
case 2:
printf("salut bebe");
break;
case 6:
printf("salut gamin");
break;
case 12 :
printf("salut jeune");
break;
case 16:
printf ("salut ado");
break;
default:
printf("salut a toi");
}
system("PAUSE");
return 0;
}

merci

lesatan -> il se passe quoi qd tu execute ?

Salut :

Je commence a me servir des classes en c++ et j´ai qqes questions :

Peut on construire 50 objet en meme temp au cour d´un programme ( avec les memes propriétés ) sans écire 50 ligne et donner des noms différents a chacuns. J´ai penser a faire un tableau d´objet, est-ce possible ?

Comment faire pour que (par exemple ) à chaque fois que j´appuye sur "enter", ca cré un nouvel objet ( tous avec les memes propriétés ) ?

voila, si vs savez aidez moi !

bye.

Mon_objet P[50]; --> crée 50 objets P en appeldant le constructeur par défaut
Mon_objet P[50](3); --> crée 50 objets P en appeldant le constructeur P(int) et en passant 3.

Pour créer un orbjet chaque fois que tu appuies sur entrée, rien ne t´empeche de faire :

Mon_objet P[50];
for(i=0;i<50;i++)
{
P[i] = Mon_objet(5);
getchar();
}

L´inconvénient de ça, c´est que ça va d´abord te créer 50 objets instanciés par défaut, puis les remplacer par défaut (vérifie la validité de la surcharge du = )

Sinon, dynamiquement :

Mon_objet* P[50]; // aucune instanciation ici
for(i=0;i<50;i++)
{
P[i] = new Mon_objet(5);
getchar();
}

Ok merci la 2eme solution est trés bien

Mais aprés comment je fait pour par exemple utilisé une fonction de ma classe sur un des objets ?

*P[x].Ma_Fonction(555);

commme ca ?

P[x]->Ma_Fonction(555);

Surtout pas comme ça :

• P[x].Ma_Fonction(555);

car avec les priorités, c´est équivalent a :

• (P[x].Ma_Fonction(555));

et ce n´est pas ce que tu veux.
Toi t uveux :

(*P[x]).Ma_Fonction(555);

ça, ça marche, mais c´est lourd et chiant a écrire. Du coup, on a inventé l´opérateur -> et, la on rejoint la réponse de Lapintade :

(*P[x]).Ma_Fonction(555);
est équivalent à :
P[x]->Ma_Fonction(555);

ok merci je vien de comprendre a quoi servé les " -> " que je voyais souvent dans des programmes.

je vais éssayer cette methode. bye.

Bonjour, je voudrais savoir si il existe une "norme" qui permet de savoir quand utiliser un int plutot qu´un long.
Car d´après le site du zéro, les deux types sont actuellement identiques sur toutes les configurations PC. D´ailleurs sur ce site l´auteur utilise un int pour les boucles de types for et long pour le reste.

hello,

si je me rappelle bien, les deux type ont été créé à l´époque où les ordi ne possédaient encore pas beaucoup de mémoire. Alors, tout ce qu´on pouvait gagner niveau place, on le prenait. Ainsi, inutile de réserver une plage de 256 bit dans la RAM si on sait qu´on va stocker dans notre variables les chiffres de 1 à 10. Alors on a créé deux variables : une qui réserve des petites places et l´aurtes de grandes.
Aujourd´hui, avec la mémoire dont on dispose, ce n´est plus nécessaire. On aurrai très bien pu ne concerver que la plus grande des deux (long), mais on a choisi de "mettre à niveau" int, je suppose parce que c´est pour que les anciens développeurs puissent continuer à utiliser les deux.

Qu´on me corrige si c´est faux.

il me semble qu´actuellement sur les machines 64 bits on a:
int->4octets
long->8octets

La seul chose qui est normalisé par le C (je crois) est que:
sizeof(short)<=sizeof(int)<=sizeof(long)

oki merci, mais vous, quel type utilisez vous habituellement ?

ah aussi je me suis trompé, l´auteur du site du zéro utilise les int seulement pour les booléens et les long pour le reste. je pense que je vais faire pareil

il y a plusieurs cas, si ce que je fais représente VRAIMENT un entier, j´utilises int.
Si ce n´est pas vraiment un entier (un isomorphisme de N ou d´un sous ensemble de N), je fais un typedef pour pouvoir le changer facilement.

oki merci

Pour déclarer un booléen on peut utiliser aussi "bool" plus simplement.

je programme en C actuellement
je vais donc utiliser un typedef comme l´a suggeré godrik pour créer un type "booléen" à partir d´un char (je connais pas plus petit ).

Perso j´utilise jamais de long, le int ca suffit amplement pour ce que j´ai a faire.
C´est comme les "double", j´utilise "jamais", float suffit.

Sinon quand je veux gratter un peu de memoire j´utilise des char ou short (respectivement 1 et 2 octets), c´est interressant sur des grand tableaux.

Extra-terrestre >> je programme en C actuellement
je vais donc utiliser un typedef comme l´a suggeré godrik pour créer un type "booléen" à partir d´un char (je connais pas plus petit ). <<

Pour faire un booléen tu n´est pas obligé de faire un typedef en C, un int suffit largement exemple :

int boolean = 0;

boolean = 0; //False
boolean = 1; //True

ouais je sais, mais là c´était pour occuper le moins de mémoire possible

j´ai essayé des sizeof sur des machines 64 bits.

Les long et int restent a 4 octets.
Un nouveau type (encore non ANSI) apparait : "__int64" ou "long long" -> un entier de 8 octets.

ce qui change surtout (et c´est normal), c´est la taille des pointeurs :

Ainsi :
sizeof(int*) ou sizeof(void*) donne 8 octets -> en effet, avec 4 octets, on était limité a l´adressage de 4 Go, on atteint a peu pres la limite maintenant.

Pour ce qui est de la gestion de booleans : inutile, dans le cas d´un retour de fonction, de renvoyer un char : de toute façon, il est converti en int (registre EAX) -> utilisez le int pour faire des retours booléens.

Utilisez le short et le char pour optimiser un peu.
Attention, la place mémoire peut varier selon que vous mettez int,char,char ou char,int,char
(cf mon tuto dans l´annexe G, je ne sais plus lequel, cf mon carte)

Sinon, si vous voulez optimiser l´information, donc faire de grands grands tableaux, la oui, faire un tableau de char est plus judicieux qu´un tableau de int.
Il existe également dans la version étendue de la STL ce qu´on appelle le "bit_vector", lui stocke des bits, donc 8 informations par octets.
(cependant, je ne m´en sers pas, a la boite, je l´ai reprogrammé)
Utilisez les opérateurs | & ~ pour manipuler les bits dans un octet.

Une derniere chose : dans une structure, vous pouvez définir des variables de moins d´un octet, avec l´opérateur :
cf mon site, annexe G.

Bonjour,
J´ai un problème avec ce code

1. include <stdlib.h>
2. include <stdio.h>
3. include <SDL/SDL.h>

int main(int argc, char *argv[])
{
SDL_Surface *ecran = NULL, *lignes[256] = {NULL};
SDL_Rect position;
int i = 0;

SDL_Init(SDL_INIT_VIDEO);

ecran = SDL_SetVideoMode(640, 256, 32, SDL_HWS
URFACE); // Hauteur de 256 pixels

for (i = 0 ; i <= 255 ; i++)
lignes[i] = SDL_CreateRGBSurface(SDL_HWSUR
FACE, 640, 1, 32, 0, 0, 0, 0); // Allocation des 256 surfaces

SDL_WM_SetCaption("Mon de´grade´ en SDL !" , NULL);

SDL_FillRect(ecran, NULL, SDL_MapRGB(ecran->format, 0, 0, 0));

for (i = 0 ; i <= 255 ; i++)
{
position.x = 0; // Les lignes sont a` gauc
he (abscisse de 0)
position.y = i; // La position verticale d
e´pend du nume´ro de la ligne actuelle
SDL_FillRect(lignes[i], NULL, SDL_MapRGB(e
cran->format, i, i, i)); // Remplissage
SDL_BlitSurface(lignes[i], NULL, ecran, &p
osition); // Collage
}

SDL_Flip(ecran);
pause();

for (i = 0 ; i <= 255 ; i++) // N´oubliez pa
s de libe´rer chacune des 256 surfaces !
SDL_FreeSurface(lignes[i]);
SDL_Quit();

return EXIT_SUCCESS;
}

J´ai cette erreur ci
warning : No newline at end of file
Merci d´avance