Je mangerais bien du GNU...
Groupe : Membres
|
Reprise du dernier message de la page précédente :
Mot-clé: auto
Description: modificateur de portée; définit une variable locale (mot clé facultatif)
Langage: C et C++
Code : C - Afficher / masquer les numéros de ligneint main() { // Identique à int x = 3; auto int x = 3; return 0; }
Édité
le 18/08/2007 à 15:39:51
par Kreeg
|
Apprenez à utiliser la STL !!
Groupe : Membres
|
La suite de la liste
-------------------------------------------------------------------------------------------------------------------------------------------------------
auto
Description : type; Modificateur de type. Permet de déclarer une variable comme locale. La mémoire allouée sera automatiquement désallouée à la fin du bloc.
Langage : C/C++
Exemple et/ou commentaire :
Code : C++ - Afficher / masquer les numéros de ligneint a; //Une variable "classique" auto int b; //Une variable automatique
Ce mot-clé n'est actuellement plus utilisé, car toutes les variables sont par défaut auto. La prochaine norme devrait lui donner un nouveau sens.
-------------------------------------------------------------------------------------------------------------------------------------------------------
break (casser en français)
Description : Instruction de branchement permettant de sortir d'une boucle for, while ou do...while. Break est aussi utilisé à la fin de chaque bloc d'instructions d'un switch, il permet de ne pas exécuter les cas se trouvant en-dessous après avoir terminé le bloc correspondant.
Langage : C/C++
Exemple et/ou commentaire :
Code : C++ - Afficher / masquer les numéros de lignewhile( x < 100 ) { //Tant que x est plus petit que 100 if( x < 0 ) //Si x est négatif break; //On sort de la boucle while cout << x << endl; x++; }
1) Si plusieurs boucles sont imbriquées, le break ne permet de sortir que d'une seule boucle.
2) Break permet également de sortir d'un if, mais il vaut mieux l'éviter.
-------------------------------------------------------------------------------------------------------------------------------------------------------
case (cas en français)
Description : Permet de déclarer un cas dans une instruction switch. La valeur associée à un cas doit être une constante de type int, short, long ou char
Langage : C/C++
Exemple et/ou commentaire :
Code : C++ - Afficher / masquer les numéros de ligneswitch(maVariableATester){ case 2: //Si la variable à tester vaut 2 //Le code a effectuer case 3: //Si la variable à tester vaut 3 //Le code a effectuer }
Si le code à effectuer ne se termine pas par un break ou return, le case se trouvant en-dessous sera également exécuter, jusqu'au prochain break ou jusqu'à la fin du switch.
-------------------------------------------------------------------------------------------------------------------------------------------------------
catch (attrape en français)
Description : Gestion des exceptions; Permet de rattraper une exception lancée par un throw.
Langage : C++
Exemple et/ou commentaire :
Code : C++ - Afficher / masquer les numéros de lignetry{ const int i = f(); /// des appels... if (i==42) throw std::runtime_error("Désolé, 42"); //Lancement d'une exception } catch(std::exception const& e){ //On rattrape les erreurs (par référence!) std::cerr << "Erreur: " << e.what() << std::endl; }
Un bloc catch doit se situer directement après un bloc try ou après un autre bloc catch.
-------------------------------------------------------------------------------------------------------------------------------------------------------
class (classe en français)
Description : Permet de déclarer une classe.
Langage : C++
Exemple et/ou commentaire :
Code : C++ - Afficher / masquer les numéros de ligneclass Vecteur{ //Les différents attributs et méthodes de ma classe };
L'accolade fermante d'un bloc de classe est toujours suivie d'un point-virgule.
-------------------------------------------------------------------------------------------------------------------------------------------------------
continue
Description : Permet de sauter une itération dans une boucle de type for, while ou do...while.
Langage : C/C++
Exemple et/ou commentaire :
Code : C++ - Afficher / masquer les numéros de lignefor( int i = 0; i < 21; i++ ) { // On itere de 0 à 20 if( i == 10 ) // Si i vaut 10 continue; //On passe à l'itération suivante en sautant ce qui suit cout << i << " " << std::flush; }
-------------------------------------------------------------------------------------------------------------------------------------------------------
default (défaut en français)
Description : Dans un bloc d'instruction switch, indique la portion de code à effectuer si le test ne correspond à aucun des case du switch.
Langage : C/C++
Exemple et/ou commentaire :
Code : C++ - Afficher / masquer les numéros de ligneswitch(maVariableATester){ //Plein de case et leur code correspondant default: //Le code a effectuer si le test ne correspond à aucun case }
-------------------------------------------------------------------------------------------------------------------------------------------------------
delete (efface en français)
Description : Désalloue la mémoire pointée par un pointeur. Le pointeur passé en argument doit avoir été alloué grâce à un new.
Langage : C++
Exemple et/ou commentaire :
Code : C++ - Afficher / masquer les numéros de ligneint* monPointeur = new int; //On crée un pointeur sur un int via new. delete monPointeur; //On désalloue la mémoire utilisée par monPointeur
1) En C++, on préfère delete à free, car delete appelle le destructeur contrairement à free.
2) On utilise delete[] pour désallouer un tableau.
-------------------------------------------------------------------------------------------------------------------------------------------------------
else (sinon en français)
Description : Indique le cas par défaut dans un test de condition if
Langage : C/C++
Exemple et/ou commentaire :
Code : C++ - Afficher / masquer les numéros de ligneif(maVariable == 3) //Code a effectuer si maVariable vaut 3 else //sinon //code a effectuer si maVariable ne vaut pas 3
-------------------------------------------------------------------------------------------------------------------------------------------------------
enum
Description : Permet de déclarer un type énuméré.
Langage : C/C++
Exemple et/ou commentaire :
Code : C++ - Afficher / masquer les numéros de ligneenum{ROUGE,BLEU,JAUNE}; //Type énuméré où l'on a pas spécifié les valeurs de chaque alias enum{ROUGE = 5,BLEU = -3,JAUNE=8}; //Type énuméré où l'on a spécifié les valeurs de chaque alias
1) Les valeurs d'un type énuméré sont toujours des int.
2) Un type énuméré est mieux qu'un #define car il a une portée, il peut par conséquent ne pas être global.
-------------------------------------------------------------------------------------------------------------------------------------------------------
export
Description : Permet de séparer le prototype de la définition d'un template
Langage : C++
Exemple et/ou commentaire : --
Remarque : Ce mot-clé n'est supporté que par un nombre restreint de compilateurs. Il est donc rarement utilisé.
-------------------------------------------------------------------------------------------------------------------------------------------------------
extern
Description : Permet de déclarer une variable globale initialisée dans un autre fichier afin de pouvoir l'utiliser dans le fichier courant.
Langage : C/C++
Exemple et/ou commentaire :
Fichier source 1:
Code : C++ - Afficher / masquer les numéros de ligneint maVariableGlobale = 2; //Variable globale
Fichier source 2:
Code : C++ - Afficher / masquer les numéros de ligneextern int maVariableGlobale; //On indique que la variable globale provient d'un autre fichier
Une variable globale doit être déclarée extern dans tous les fichiers sauf 1 où elle doit être initialisée.
-------------------------------------------------------------------------------------------------------------------------------------------------------
Je compléterai dès que j'aurais du temps. N'hésitez si vous avez des commentaires ou remarques.
Édité
le 25/09/2007 à 20:08:20
par Nanoc
|
Groupe : Membres
|
L'intérêt d'auto est effectivement limité aujoud'hui. Toutesfois, il va être détourné dans le prochain standard du C++0x pour déduire de façon automatique un type complexe de variable en fonction d'une expression.
Il est vrai que break va permettre de sortir du bloc d'un if. Ceci dit, je ne l'ai jamais vu utilisé sciement (ortho?) pour cela. J'ai peur que d'en parler introduise une confusion chez les débutants qui vont voir un "if(cond)break;" pour sortir d'une boucle.
Pour les exceptions, Il serait mieux que l'exemple repose sur les exceptions standard (cf FAQ developpez pour des exemples)
"continue" n'a rien d'obsolète. (Je soupçonne une erreur de copier-coller)
Il faux est de dire que delete remplace free. Note: il peut être intéressant de préciser que delete fera appel au destructeur (éventuellement "contrairement à free()")
("export", c'est toute une famille (EDG => comeau, intel ; et je crois bien qu'il y en a d'autres) de compilos C++ qui supporte export pour les templates)
|
Apprenez à utiliser la STL !!
Groupe : Membres
|
Merci pour tes remarques toujours aussi pertinentes.
Par exceptions standard, je suppose que tu veux parler des std::error ? Je corrigerai si c'est bien à ça que tu penses.
Pour le auto, je préfère laisser comme ça, vu que la nouvelle norme n'est pas encore sortie, ni définitive.
|
Groupe : Membres
|
std::exception.
Pour auto, c'est le "obsolète" qui me gêne vu que cela ne va pas durer.
|
template <class Skypers>
Groupe : Membres
|
virtual
Description : Polymorphisme ; Permet d'étendre le polymorphisme d'une classe en rendant une méthode virtuelle.
Langage : C++
Exemple et/ou commentaire :
Code : C++ - Afficher / masquer les numéros de ligneclass Dog { public : Dog(){}; virtual ~Dog(){}; virtual void Run(const int value); // Méthode virtuelle private : // Attribus de Dog }; class Labrador : public Dog { public : Labrador(){}; ~Labrador(){}; void Run(const int value); // Méthode remplacée private : // Attribus de Labrador };
Déclarer une méthode virtuelle permet de pouvoir la remplacer si la classe dont elle est issue est dérivable.
Code : C++ - Afficher / masquer les numéros de ligne// Utilisation Dog chien; chien.Run(15); // Le chien va bouger Labrador labrador; labrador.Run(15); // Le chien (le labrador) va bouger comme un labrador delete labrador;
La règle est la suivante : Si au moins une méthode d'une classe est virtuelle, alors le destructeur de la classe doit aussi l'être.
Les ADT
Lorsqu'une classe possède au moins une méthode qui DOIT être remplacée, on la dit ADT (Abstract Data Type, ou type de donnée abstraite). Cette classe est ainsi ininstanciable. De plus, la méthode qui DOIT être remplacée est nommée une méthode virtuelle pure
Code : C++ - Afficher / masquer les numéros de ligneclass Mammifere { public : Mammifère(){}; virtual ~Mammifère(){}; virtual void Move() = 0; // = 0 permet de déclarer une méthode virtuelle pure private : // Attribus }; class Lapin : public Mammifère // Le lapin est un Mammifère { public : Lapin(){}; ~Lapin(){}; void Move(); // Doit être implétée };
// Déclaration, intialisation et utilisation d'une classe dérivée d'une ADT Mammifere *rabit = new Lapin; rabit->Move(); delete rabit
Pour finir, si une méthode est déclarée virtuelle dans une classe mère, elle n'a pas besoin de reêtre déclarer virtuelle dans les classes filles.
.:: SGLCS : |||||||||| 100% -
.:: Conception moteur SGLEngine : |||||||||| 10% -
.:: Lorsque Chuck Norris ne trouve pas le sommeil, les moutons lui disent combien ils sont.
|
Apprenez à utiliser la STL !!
Groupe : Membres
|
Euh oui en effet std::exception pas error.
@Skypers En C++, il n'y a pas de méthodes, mais des fonctions membres.
Un destructeur ne doit pas forcément être virtuel si une des fonctions membres est virtuelle.
Si la fonction membre n'est pas déclarée virtuelle dans la classe fille, on perd alors la notion de polymorphisme, pour arriver à de l'héritage simple avec masquage de fonction.
Édité
le 18/08/2007 à 21:00:28
par Nanoc
|
Groupe : Membres
|
+1 à "fonction membre"
Le destructeur doit être virtuel pour supporter une destruction polymorphique (-> dans pratiquement toutes les FAQ C++). Il est acceptable de définir des destructeurs protégés non virtuels (malgré que toutes les autres fonctions soient virtuelles) ; c'est même une des techniques conseillées dans le bouquin sur la qualité de H.Sutter et A.Alexandrescu ( C++ Coding standards, puiblié chez Addisson-Wesley, traduit)
Le masquage c'est autre chose : c'est quand on déclare une nouvelle fonction de signature différente (cf FAQ C++ de developpez)
Et effectivement, virtual est implicite lorsque l'on _supplante_ [1] une fonction virtuelle dans la classe fille.
[1] "Remplacer" est pas mal. Mais c'est "supplanter" qui a remporté le "consensus" des meilleurs termes non officiels (officiellement -> "redéfinir")
virtual sert également pour hériter virtuellement. C'est une technique liée à l'héritage multiple afin de ne dériver qu'une seule fois (et non plusieurs) d'une classe depuis plusieurs chemins.
Sauf feinte obscure (au singulier), une classe est toujours dérivable.
Les types génériques (template) sont ce qui se rapprochent le plus des ADT en C++ -- j'ai même envie de dire que cela n'a rien à voir avec les classes abstraites. Une classe abstraite est juste ça : une "classe abstraite", qui a la propriété d'être non instanciable.
-> http://fr.wikipedia.org/wiki/Type_abstrait
PS: delete n'est pas utilisable sur les objets automatiques vivant sur la pile.
|
Apprenez à utiliser la STL !!
Groupe : Membres
|
Citation : ImghsEt effectivement, virtual est implicite lorsque l'on _supplante_ [1] une fonction virtuelle dans la classe fille.
OK, je l'ignorais d'où la confusion avec le masquage.
Citation : Imghs delete n'est pas utilisable sur les objets automatiques vivants sur la pile.
Est-ce que tu aurais un exemple ou un lien pour que je comprenne ?
|
Groupe : Membres
|
Pour le delete, cf le "delete labrador" dans le code de -Skypers- ou l'objet "labrador" vit sur la pile et non le tas (pas alloué anec "new" quoi).
|
Apprenez à utiliser la STL !!
Groupe : Membres
|
Ah c'était donc ça !
Je cherchai plus compliqué et en rapport avec mon topic sur le delete.
|
template <class Skypers>
Groupe : Membres
|
Pour ce qui est de "remplacer", j'ai piqué le terme dans un bouquin de C++... Discutable ?
Par contre je ne comprends pas qu'il n'y est pas de "méthode" en C++. La fonction membre d'une classe est une fonction membre, je me trompe ?
.:: SGLCS : |||||||||| 100% -
.:: Conception moteur SGLEngine : |||||||||| 10% -
.:: Lorsque Chuck Norris ne trouve pas le sommeil, les moutons lui disent combien ils sont.
|
Groupe : Membres
|
Pas une question de "discutable". Officiellement c'est "redéfinir", mais cela ne donne aucune indication de ce qui se passe vraiment : on remplace/supplante.
Officiellement : que des fonctions. Libre ou membre.
Méthode est un terme que l'on retrouve régulièrement dans les langages OO où toutes les fonctions membre sont virtuelles. Et si on s'en tient à la définition UML, une méthode est en gros une implémentation de fonction d'interface. Du coup, dans la communeauté C++ tu as ceux qui considèrent que méthode == fonction membre. Et ceux qui considèrent que méthode == fonction membre virtuelle.
Bref, c'est un terme impropre au langage que l'on préfère donc éviter.
|
template <class Skypers>
Groupe : Membres
|
Okay merci de la précision !
.:: SGLCS : |||||||||| 100% -
.:: Conception moteur SGLEngine : |||||||||| 10% -
.:: Lorsque Chuck Norris ne trouve pas le sommeil, les moutons lui disent combien ils sont.
|
apprenti
Groupe : Membres
|
Après vérification dans la norme pour les type de données :
Citation : ISO/IEC 14882:2003 section : 3.9.1 Fundamental types
A char, a signed char, and an unsigned char occupy the same amount of storage
[...]
There are four signed integer types: “signed char”, “short int”, “int”, and “long int.” In this list, each type provides at least as much storage as those preceding it in the list. Plain ints have the natural size suggested by the architecture of the execution environment
[...]
For each of the signed integer types, there exists a corresponding (but different) unsigned integer type: “unsigned char”, “unsigned short int”, “unsigned int”, and “unsigned long int,” each of which occupies the same amount of storage and has the same alignment requirements as the corresponding signed integer type
[...]
There are three floating point types: float, double, and long double. [...] The set of values of the type float is a subset of the set of values of the type double; the set of values of the type double is a subset of the set of values of the type long double.
[...]
Specializations of the standard template numeric_limits (18.2) shall specify the maximum and minimum values of each arithmetic type for an implementation.
Traduction approximative (= : occupe la meme place en mémoire, < : occupe au moins la meme place en mémoire) :
char = signed char = unsigned char
signed char < short int < int < long int
unsigned char < unsigned short int < unsigned int < unsigned long int
short int = unsigned short int
int = unsigned int
long int = unsigned long int
float = double = long double
La mémoire occupée par un int est la taille naturel de l'architecture de l'ordinateur (32 bits pour un processeur 32 bits, traduction pas très clair, si quelqu'un peut traduire ca mieux)
numeric_limits spécifie le minimum et le maximum de chaque type pour une implémentation (traduction pas très clair non plus)
|
Groupe : Membres
|
Oui, oui. Quant à std::numeric_limits<>, j'ai également donné un lien à son sujet.
p.ex. le max d'un int est std::numeric_limits<int>::max(). Et plein d'autres infos sont disponibles, d'où le lien.
Quant à int, ils ne disent que que c'est sensé être optimal pour la plateforme (bus, proc(s), ...). Mais je crois bien que c'est encore plus complexe que cela. Déjà abordé dans d'autres forums. Je ne veux pas direde bétises, mais il me semble bien avoir vu des messages de Jean-Marc Bourguet à ce sujet sur developpez.
PS: le bon signe à utiliser est <=
PPS: l'autre certitude est que sizeof(char) == 1.
EDIT: je n'avais pas reconu que Freedom avait été le premier a soulever l'erreur 
Édité
le 20/08/2007 à 00:40:11
par lmghs
|
apprenti
Groupe : Membres
|
Oui je sait qu'on l'a déjà dit, c'est meme moi qui l'ai dit en premier, mais tu as répondu dans le message d'après qu'il n'y avait pas de définition, et que les limites étaient ecrites dans numeric_limits. Les limite sont bien écritent dans cette classe, mais ma définition n'était pas fausse pour autant.
PS : J'ai utiliser < et = après avoir donner leurs avoir donner une définition pour comprendre l'écriture, dans la norme c'est écrit en toute lettre.
Edit : Pour les int, lis ma citation de la norme j'ai peut etre mal traduit, mais pour moi c'est écrit que int est le type naturel de l'architecture. (C'est la norme texto que j'ai cité)
Édité
le 20/08/2007 à 00:50:49
par Freedom
|
Groupe : Membres
|
Quand je parlais des définitions, je faisais allusions à des définitions numériques comme celle de dire que le max d'un short est 16383.
J'étais bien d'accord avec toi depuis le debut -- sauf que je n'avais pas parcuté que tu étais le même que le premier à avoir soulevé le problème (j'ai edité mon message juste que tu ne répondes ^^')
Pour en revenir aux int, c'est complexe. Il y a au moins deux choses dans l'architecture qui sont "dimensionnantes" sur le plan technique : bus et proc qui varient plus ou moins indépendament . Et il y aussi des problèmes de compatbilité ascendante et autres choix du genre. Et il y a la norme... Bref, pas si simple.
EDIT: Peut-être un quiproquo à cause de mon emploi de "mitouiller" comme dans "me too" (angl-AOL-isme)
Édité
le 20/08/2007 à 01:08:42
par lmghs
|
apprenti
Groupe : Membres
|
Ha d'accord, j'avais pas compris ton premier message comme sa.
Pour les int et l'architecture, je l'ai écrit car c'était dans la meme section de la norme que les plage de valeur, après je ne connais pas les détails technique d'un tel élément.
|
Groupe : Membres
|
Voilà, après la correction du bug sur les post-it, la recopie au "propre" à recommencée (elle n'est pas encore finie loin de là, mais ça avance).
Je vous informe en passant que les règles de rédaction ont changé :
Mettez aussi une copie de votre "forumlaire" entre les balises "<code>" pour facilité la tache de recopie dans le post-it. (Comme la balise zcode ne fonctionne pas pour le moment ne l'utilisez pas.)
Un exemple :
Code : Autre - Afficher / masquer les numéros de ligne<police nom="impact">do</police> <couleur nom="marine">Description : </couleur> Ce mot clef est utilisé dans une boucle. Il s'utilise avec <gras>while</gras> et a pratiquement la même utilisation que <gras>while </gras>seul, sauf que la boucle sera exécutée au moins une fois, allez comprendre à la suite. <couleur nom="violet">Langage : </couleur>C et C++<souligne> Exemple et/ou commentaire :</souligne><code type="cpp">int i = 3; do // Si on fait une boucle avec do, l'ordi exécute donc la boucle sans se soucier de quoi que ce soit. { cout << "Je ne dois pas bavarder en classe." << endl; } while(i < 1); // On n'oublie pas qu'il y a un ; à la fin d'un while avec un do. /* Voici la preuve que la boucle s'exécute au moins une fois car la condition de la boucle est située à la fin de la boucle, et comme l'ordi lis les instructions dans l'ordre, il exécute la boucle et lis ensuite la condition. Dans notre cas bien sur l'ordi ayant lu la condition ne fera plus la boucle par la suite <img src="Templates/images/smilies/clin.png" alt=";)" class="smilies"> .*/</code>
Ce mot clef est utilisé dans une boucle. Il s'utilise avec while et a pratiquement la même utilisation que while seul, sauf que la boucle sera exécutée au moins une fois, allez comprendre à la suite.
Langage : C et C++
Exemple et/ou commentaire :Code : C++ - Afficher / masquer les numéros de ligneint i = 3; do // Si on fait une boucle avec do, l'ordi exécute donc la boucle sans se soucier de quoi que ce soit. { cout << "Je ne dois pas bavarder en classe." << endl; } while(i < 1); // On n'oublie pas qu'il y a un ; à la fin d'un while avec un do. /* Voici la preuve que la boucle s'exécute au moins une fois car la condition de la boucle est située à la fin de la boucle, et comme l'ordi lis les instructions dans l'ordre, il exécute la boucle et lis ensuite la condition. Dans notre cas bien sur l'ordi ayant lu la condition ne fera plus la boucle par la suite ;) .*/
|
F...F...Frieza !!!
Groupe : Membres
|
Compris 
EDIT : cool ma description hein 
Édité
le 15/09/2007 à 21:33:16
par
Bientôt site web sur le C++.
Avancement : 73%
|
Groupe : Membres
|
oui elle est bien
|
Apprenez à utiliser la STL !!
Groupe : Membres
|
Bon puisque ça a repris, je m'y remets (il manque d'ailleurs une bonne partie de ceux que j'ai rédigé dans le post-it)
------------------------------------------------------------------------------------------
inline
Description : Optimisation. Déclarer une fonction inline indique au compilateur qu'il devra recopier le corps de la fonction à l'endroit de l'appel, dans le but d'augmenter la vitesse d'exécution du code.
Langage : C++
Exemple et/ou commentaire : Code : C++ - Afficher / masquer les numéros de ligneinline int addition(int a, int b) { return a+b; }
En réalité, c'est le compilateur qui décide si votre fonction sera inilne ou pas. Vous ne faites que suggérer cette idée.
------------------------------------------------------------------------------------------
main
Description : Fonction. Point d'entrée du programme. L'exécution du programme commence par cette fonction et se termine (si on ne rencontre pas d'erreur) à la fin de celle-ci.
Langage : C et C++
Exemple et/ou commentaire : Il existe plusieurs signatures différentes acceptées par les compilateur. La signature "standard" de la fonction main est :
Code : C++ - Afficher / masquer les numéros de ligneint main(int argc, char* argv[])
------------------------------------------------------------------------------------------
new
Description : Opérateur. Alloue de la mémoire (sur le tas) pour la création d'une variable. new contrairement à malloc, appelle le constructeur du type passé en argument.
Langage : C++
Exemple et/ou commentaire : Code : C++ - Afficher / masquer les numéros de lignemaClasse* ptr = new maClasse; //crée de l'espace mémoire de type sizeof(maClasse) et appelle le constructeur de maClasse pour remplir cette espace mémoire.
Toute mémoire allouée via l'opérateur new, doit être libéreé via l'opérateur delete.
------------------------------------------------------------------------------------------
mutable
Description : Variable. Qualificateur de type qui indique qu'un attribut membre peut évoluer même si l'objet d'où il est tiré est considéré comme non modifiable dans la portée courante.
Langage : C et C++
Exemple et/ou commentaire : ---
------------------------------------------------------------------------------------------
namespace
Description : Permet de créer un espace de nommage. Il n'est pas obligatoire de fournir un nom à un espace de nommage, on parle alors d'espace de noms anonyme. Pour accéder aux éléments d'un espace de nommage, on utilise l'opérateur de résolution de portée (::) ou le mot-clé using.
Langage : C++
Exemple et/ou commentaire : Code : C++ - Afficher / masquer les numéros de lignenamespace monEspace{ //Les fonctions, classes, structures, variables de //cet espace de nommage }
Il n'y a pas de ; après l'accolade fermante.
------------------------------------------------------------------------------------------
operator
Description : Permet de surcharger un opérateur pour en modifier l'effet ou pour lui donner une signification dans le cadre d'une classe par-exemple.
Langage : C++<souligne>
Exemple et/ou commentaire : Code : C++ - Afficher / masquer les numéros de ligneclass maClasse{ maClasse operator+ (const maClasse& a, const maClasse& b) { //Définition de l'addition pour ma Classe } };
Tous les opérateurs sont surchargeables sauf:
.
?:
sizeof
::
typeid
.*
--------------------------------------------------------------------------------------------
a compléter
Édité
le 25/11/2007 à 16:03:59
par Nanoc
|
Groupe : Membres
|
Merci de participer autant!
Il me reste plus que ton dernier poste à donner à Fcp ( que je remercie encore et encore pour son aide).
Mais j'ai un souci avec 'virtual'. Comme vous avez un peu débattu dessus, et que je m'y perds, je ne sais pas si je dois donner le post ( http://www.siteduzero.com/forum-83-175472-1623555.html#r1623555 ) tel quel ou le modifier...
Encore merci à tous/toutes les participant(e)s! J'en apprends sans cesse!
EDIT : on (asmanur) vient de me signaler que le code pour le mot clef "catch" ne fonctionne pas à la compilation.
Voici le code pour rafraichir les souvenirs :
Code : C++ - Afficher / masquer les numéros de lignetry{ //Code dangereux throw std::exception monErreur; //Lancement d'une exception } catch(std::exception monErreur){ //On rattrape les erreurs //Instructions en cas d'erreur de ce type }
Est-ce que c'était censé compiler?
Sinon pour :
continue
Description : Permet de sauter une itération dans une boucle de type for, while ou do...while.
Nanoc : qu'entends tu par "itération"?
Édité
le 24/09/2007 à 21:20:03
par Hiura
|
Apprenez à utiliser la STL !!
Groupe : Membres
|
Attends un peu pour le virtual, j'en referai une version qui contient toutes les modifs proposées.
Le code du catch est correct mais je pense qu'il faut ajouter des précisions.
Par itérations j'entends "tour de boucle"
a+
|
Groupe : Membres
|
Tout d'abord merci pour cette réponse rapide. 
Citation : NanocAttends un peu pour le virtual, j'en referai une version qui contient toutes les modifs proposées.
C'est gentil de ta part.
Citation : NanocLe code du catch est correct mais je pense qu'il faut ajouter des précisions.
Justement, je ne comprends pas comment fonctionne std::exception. (Je sais utiliser le try/throw/catch avec une classe error de ma conception, mais pas avec std::exception...)
Citation : NanocPar itérations j'entends "tour de boucle"
Mais c'est pas tout à fait ça sauf erreur : ça renvois au début de la boucle mais ça ne saute pas de "tour". Me trompe-je?
|
Groupe : Membres
|
inline
Quand on parle d'"indication", on entend en fait que l'on aimerait que la fonction soit inlinée, mais le compilo n'est pas obligé d'accepter.
(l'option "+w2" avec le compilo de Solaris fait émettre un warning pour toutes les fonctions trop grosses que le compilo refuse d'inliner)
De plus, on peut mettre une fonction inline où il nous plait. Non seulement, le fichier n'a pas à être un fichier d'en-tête en .h (il est fréquent de voir des .i, .inl, ...), mais en plus on peut tout à fait déclarer une fonction inline dans un .cpp si on ne désire pas la partager.
new peut également être employé pour les construction de placement, détourner l'allocation, ... (trucs à interdire aux 0, et à 99% des autres aussi)
mutable n'annule pas le modificateur const. C'est un qualifieur ("qualificateur" ?) de type qui indique qu'un attribut membre peut évoluer même si l'objet d'où il est tiré est considéré comme non modifiable dans le contexte courant.
Jusqu'à présent, je m'en suis essentiellement servi pour des classes proxy ou des membres mutex.
namespace
Il est parfaitement conséillable de ne pas donner de nom à un espace de noms. On parle alors d' espace de noms anonyme. C'est équivalent à static du C qui permettait de limiter l'accessibilité de certaines choses à l'unité de traduction courante (UT == .cpp + tous les .h inclus)
operator
L'exemple ne compilera jamais : on ne peut pas définir d'opérateur sur les types de bases.
Si ',' et ';' sont considérés comme des opérateurs (j'ai un doute, à vérifier), ils ne sont pas surchargeables non plus.
Et il est possible de définir des opérateurs de convertions.
catch
Le code n'est effectivement pas correct.
throw attend une expression, et non une déclaration/définition.
Code : C++ - Afficher / masquer les numéros de lignetry{ const int i = f(); /// des appels... if (i==42) throw std::runtime_error("Désolé, 42"); //Lancement d'une exception } catch(std::exception const& e){ //On rattrape les erreurs (par référence!) std::cerr << "Erreur: " << e.what() << std::endl; }
(Plus dans la FAQ de developpez si je me souviens bien)
|
Apprenez à utiliser la STL !!
Groupe : Membres
|
Citation : ImghsDe plus, on peut mettre une fonction inline où il nous plait. Non seulement, le fichier n'a pas à être un fichier d'en-tête en .h (il est fréquent de voir des .i, .inl, ...), mais en plus on peut tout à fait déclarer une fonction inline dans un .cpp si on ne désire pas la partager.
On m'avait toujours dit que c'était interdit. Grave erreur !
Citation : Imghsnew peut également être employé pour les construction de placement, détourner l'allocation, ... (trucs à interdire aux 0, et à 99% des autres aussi)
C'est pourquoi j'ai "omis" ce point.
Citation : Imghsmutable n'annule pas le modificateur const. C'est un qualifieur ("qualificateur" ?) de type qui indique qu'un attribut membre peut évoluer même si l'objet d'où il est tiré est considéré comme non modifiable dans le contexte courant.">
Je comprends pas la nuance. Cela annule bien l'effet de "const", l'objet devient modifiable ou alors, il y a ncore un petit détail subtile.
Citation : ImghsIl est parfaitement conséillable de ne pas donner de nom à un espace de noms. On parle alors d'espace de noms anonyme. C'est équivalent à static du C qui permettait de limiter l'accessibilité de certaines choses à l'unité de traduction courante (UT == .cpp + tous les .h inclus)
D'accord, je corrige.
Citation : ImghsL'exemple ne compilera jamais : on ne peut pas définir d'opérateur sur les types de bases.
Erreur stupide, je corrige.
Citation : ImghsSi ',' et ';' sont considérés comme des opérateurs (j'ai un doute, à vérifier), ils ne sont pas surchargeables non plus.
, est surchargeable et ; n'est pas un opérateur.
Pour ce qui concerne le catch, je corrige. Il manquait la référence.
Merci à toi pour tes précisions.
Édité
le 25/09/2007 à 20:09:28
par Nanoc
|
The cake is a lie!
Groupe : Membres
|
Je reformule ce que Imghs disait
mutable est spécifique à des variables membres non-constante et non-statique
Ce mot clé permet de dire que cette variable est toujours modifiable même lorsque l'objet est dans une contexte non-modifiable:
Code : C++ - Afficher / masquer les numéros de ligne#include <iostream> class A { mutable int m_nbAcces; int m_bidon; public: A() : m_bidon( 0 ), m_nbAcces( 0 ) {} int getMembre() const { // peut être modifié m_nbAcces++; return m_bidon; } void setMembre( int i ) { m_bidon = i; } int getNbAcces() const { return m_nbAcces; } }; void afficher( const A & a ) { // a est constant donc non modifiable dans ce contexte std::cout << "le membre de valeur " << a.getMembre(); std::cout << " a été lu " << a.getNbAcces() << " fois" << std::endl; } int main() { A a1; A a2; a1.setMembre( 11 ); a2.setMembre( 22 ); afficher( a1 ); afficher( a1 ); afficher( a2 ); return 0; }
|
Groupe : Membres
|
Citation : NanocCitation : lmghsDe plus, on peut mettre une fonction inline où il nous plait. Non seulement, le fichier n'a pas à être un fichier d'en-tête en .h (il est fréquent de voir des .i, .inl, ...), mais en plus on peut tout à fait déclarer une fonction inline dans un .cpp si on ne désire pas la partager.
On m'avait toujours dit que c'était interdit. Grave erreur !
Je ne suis pas sûr de comprendre ce que tu entends pas "grave erreur". Ce que l'on te disait, ou ce que j'ai écrit ?
En fait dis comme ça, c'est le problème pris à l'envers et généralisé après. C'est un peu comme si on disait que tous les véhicules qui ont des roues doivent consommer du carburant fossile ("silogisme" ? (c'est vieux la philo) ^^')
La seule obligation (!= interdiction), c'est que le compilateur (!= éditeur de liens) doit voir la définition d'une fonction inlinée là où l'on s'en sert. Après, on fait comme il nous plait pour assurer la présence de la définition.
Simule le (/comprend le fonctionnement du) préprocesseur (les compilo *nix ont une option -E pour cela), cela te montrera l'unité de traduction finale qui sera compilée. Reprend l'obligation que j'ai énoncée, et tous les comments devraient te sauter aux yeux.
Après, détail, l'éditeur de lien traite les fonction déclarées inline différement pour ne pas créer de conflit, même quand elles ne sont pas inlinées.
Citation : NanocCitation : lmghsnew peut également être employé pour les construction de placement, détourner l'allocation, ... (trucs à interdire aux 0, et à 99% des autres aussi)
C'est pourquoi j'ai "omis" ce point.
Vous avez déjà dû le remarquer, j'ai critiqué la pertinence d'établir une liste de mots clés. Cette remarque est dans la continuité. Un 0 n'a pas à connaitre cette liste de mots clés car elle ne lui apprendra rien sur comment s'utilise le langage -- la syntaxe ne peut pas déjà pas suffir. Si on considère cette liste comme une référence en devenir, alors pourquoi écarter certaines utilisations de ces mots clés ?
Bref, ce n'est que de la réflexion, je me doute bien que mon avis est n'est qu'un avis
Citation : NanocCitation : lmghsSi ',' et ';' sont considérés comme des opérateurs (j'ai un doute, à vérifier), ils ne sont pas surchargeables non plus.
, est surchargeable et ; n'est pas un opérateur.
Arf. Au temps pour moi alors.
Citation : NanocPour ce qui concerne le catch, je corrige. Il manquait la référence.
La référence, c'est juste de la bonne pratique à cause des hiérarchies d'exceptions -- enfin, il y a aurait eu potentiellement une erreur subtile avec d'autres hiérarchies -- et une copie inutile.
L'erreur était dans la ligne du throw.
Citation : NanocMerci à toi pour tes précisions.
Avec plaisir.
Pour mutable, MatteX a apporté des précisions, par rapport à l'aspect membre. Plus que cela n'annule rien du tout -- enfin, disons que c'est mal formulé.
La question a été soulevée aujourd'hui sur fclc++ -- enfin, au départ c'était une question relative aux propos d'Herb Sutter dans son Exceptional C++. Et la réponse touche à la notion même de quand mutable est pertinent.
PS: L mghs comme Luc (et pas I). Va falloir que je corrige mon pseudo un de ces quatres.
|
Groupe : Membres
|
Bonjour,
je crois qu'il y a une erreur sur la liste des mots clés.
En effet, time_t n'est pas un mot clé mais un type défini dans <ctime> :
lien vers cpluslpus.com. Par contre wchar_t en est un.
|
Tutoriels
Communauté
Mon compte
Recherche
Livre d'or
Publicité
Kreeg
