The cake is a lie!
Groupe : Membres
|
Reprise du dernier message de la page précédente :
Effectivement, return est une instruction de saut (traduction à la main de "Jump Statement") comme ses trois confrères alors que if est une instruction conditionnelle et while une instruction itérative....
Il reste que ce ne sont pas des fonctions!
J'aimerais ajouter qu'il existe aussi goto dans les "Jump Statement" (ok ok! pas d'attaque. On ne peux lui empêcher d'exister ce mot-clé, c'est le grand-père des boucles!)
|
IVe internationale !
Groupe : Membres
|
pour return, tu pourrais aussi parler des valeures EXIT_SUCCES et EXIT_FAILURE... (0 et -1)
Citation : MarxLes philosophes n'ont fait qu'interpréter diversement le monde, il s'agit maintenant de le transformer.
|
Apprenez à utiliser la STL !!
Groupe : Membres
|
Pour return, j'ai mis fonction, car ça entrait (pour moi) dans une catégorie de mots-clés, les mots-clés apparentés aux fonctions. Mais en effet c'est maladroit, je vais changer ça.
Pour les EXIT_SUCCES et EXIT_FAILURE, ce ne sont pas des mots-clés.
J'ai corrigé selon les propositions de lmghs les transtypages.
|
Tendou : Royaume de dieu
Groupe : Membres
|
j'ai remarqué une erreur au niveau du mot-clé 'throw'. en effet tu dis que 'throw' ne peut etre utilisé que dans un bloc 'try'. ce qui est faux. 'try' attrappe les exceptions qui se trouve dans son bloc, mais l'on peut tout à fait lancer une exception en dehors d'un bloc 'try'
|
Apprenez à utiliser la STL !!
Groupe : Membres
|
Ceci a déjà été débatu précédemment.
throw se trouve dans un bloc try de toute façon (même si c'est plus bas dans la pile), sinon le programme plante.
|
The cake is a lie!
Groupe : Membres
|
Oui mais ici l'explication n'est pas assez clair car
Code : C++ - Afficher / masquer les numéros de lignevoid faitrien() { throw std::exception( "\"Je fais rien\", j'ai dit!" ); }
est totallement légal et il n'y a visiblement pas de bloc try. L'exception sera attrapé par l'OS si le programme ne l'attrape pas lui-même.
On peut spécifier qu'entre le début du programme et le lancement de l'exception (dans la pile des appels) il doit y avoir une structure try-catch capable de de gérer l'exception. Car la description qui est présente n'aide en rien.
Imagine :
Code : C++ - Afficher / masquer les numéros de lignevoid faitrien() { throw std::exception( "..." ); } int main() { try { faitrien(); return 0; } catch( int i ) { std::cout << "Code d'erreur : " << i << std::endl; return i; } }
Selon la description du mot clé et l'explication lue dans ce post (ah oui parce que sinon on ne sait pas que d'attraper l'exception dans une fonction appelante est légale) tout est correct pourtant l'exception ne sera pas attrapée et retransmise après le programme et l'OS affichera un de ses messages d'erreur qui est tout sauf pratique.
Maintenant je crois que la définition du mot clé throw ne devrait pas expliquer comment il doit être attrapé car c'est le travail de try-catch... throw ne sert qu'à soulever ou retransmettre une exception. Le reste sera expliqué dans un tuto.
|
Apprenez à utiliser la STL !!
Groupe : Membres
|
Tout à fait d'accord avec ta dernière phrase.
|
Apprenez à utiliser la STL !!
Groupe : Membres
|
extern
Description : Permet de déclarer une variable ou une fonction initialisée ou définie dans le cas d'une fonction dans une autre portée; typiquement dans un autre fichier.
Langage : C et C++
Exemple et/ou commentaire :
Fichier a.cpp:
Code : C++ - Afficher / masquer les numéros de ligneint a=12; //Déclaration d'un entier
Fichier b.cpp
Code : C++ - Afficher / masquer les numéros de ligne
-------------------------------------------------------------------------------------------------------
friend
Description : Permet de déclarer une classe A ou une fonction f() comme amie d'une classe B. Les fonctions et classes amies auront ainsi accès à tous les attributs et fonctions de B qu'elles soient privées, protégées ou publiques.
Langage : C++
Exemple et/ou commentaire :
Code : C++ - Afficher / masquer les numéros de ligneclass B{ friend class A; //A déclarée comme amie de B friend void f(); //f() déclarée comme amie de B //Attributs et fonctions membres de la classe };
-------------------------------------------------------------------------------------------------------
static
Description : Permet de déclarer une variable à l'intérieur d'une fonction qui sera commune à tous les appels. C'est donc comme une variable globale mais dont la portée est limitée à l'intérieur d'une fonction.
En C++, il est aussi possible de déclarer un attribut d'une classe somme static, cette variable est partagée par toutes les instances de la classe et elle existe même si aucune instance n'est créée.
Une fonction membre static peut-être appelée même si aucune instance de la classe n'a été créée mais elle n'a accès qu'aux attributs statiques et aux autres fonctions membres static.
Finalement static sert aussi à limiter la portée d'une variable àl'unité de traduction courante, c'est-à-dire un fichier .cpp et tous les .h inclus.
Langage : C et C++
Exemple et/ou commentaire :
Code : C++ - Afficher / masquer les numéros de ligneclass A{ static int compteur; //Variable static commune à toutes les instances de A static f(); //Fonction membre statique };
Une fonction membre static ne peut pas être virtuelle.
-------------------------------------------------------------------------------------------------------
struct
Description : Identique au mot-clé class. La seule différence réside dans le fait que par défaut les attributs sont publiques et non pas privés comme dans les class. En C, les structures ne peuvent contenir que des attributs.
Langage : C et C++
Exemple et/ou commentaire :
Code : C++ - Afficher / masquer les numéros de lignestruct maStructure { int a; //Un attribut publique de maStructure void f(); //Une fonction membre publique de maStructure };
-------------------------------------------------------------------------------------------------------
typedef
Description : Permet de renommer un type pré-existant afin de rendre le code source plus lisible.
Langage : C et C++
Exemple et/ou commentaire :
Code : C++ - Afficher / masquer les numéros de ligne//On crée l'alias Matrice pour les tableaux dynamiques 2D typedef std::vector<std::vector <int> > Matrice;
-------------------------------------------------------------------------------------------------------
typeid
Description : Opérateur qui renvoie une référence sur un type_object, un objet qui décrit l'objet passé en argument.
Langage : C++
Exemple et/ou commentaire :
Code : C++ - Afficher / masquer les numéros de lignetemplate <typename T> class A{ //Déclaration d'une classe template void f(T a){ //Fonction membre prenant en argument un objet de type non-défini if(typeid(a) == typeid(int)){ //Si a est un entier //Code particulier dans ce cas } //Reste de la fonction } //Reste de la classe };
-------------------------------------------------------------------------------------------------------
typename
Description : Permet de décrire un type indéterminé dans le cadre d'une fonction ou d'une classe template. Ce mot-clé permet également d'indiquer au compilateur qu'un identifiant est un type et pas une variable ou un objet dans les cas où le compilateur ne pouvait le deviner seul. Pour plus de détails, voir ici.
Langage : C++
Exemple et/ou commentaire :
Code : C++ - Afficher / masquer les numéros de lignetemplate <typename T> //On définit T comme un type indéterminé class A{ //Déclaration d'une classe template //Reste de la classe };
-------------------------------------------------------------------------------------------------------
using
Description : Permet d'importer tout ou une partie d'un espace de nom dans la portée courante, afin d'utiliser le contenu de ce namespace sans utiliser l'opérateur de résolution de portée à chaque appel de fonction. Permet également dans le cadre d'un hériage de définir quelle fonction membre utiliser, celle redéfinie dans la classe fille ou celle héritée. C'est ce qui permet de faire sauter le masquage.
Langage : C++
Exemple et/ou commentaire :
Code : C++ - Afficher / masquer les numéros de ligne#include <iostream> std::cout << "Hello world" << std::endl; //On est ici obligé d'utiliser std:: pour spécifier quel cout utiliser using namespace std; //Permet d'utiliser l'entier des fonctions se trouvant dans //l'espace de nommage std, sans les précéder du std:: cout << "Hello World" << endl; //On peut ici utiliser cout sans std::
On peut aussi n'importe qu'une seule fonction.
Code : C++ - Afficher / masquer les numéros de ligneusing std::cout; cout <<"Hello World" << std::endl;
-------------------------------------------------------------------------------------------------------
void
Description : void est utilisé pour définir des fonctions qui ne renvoient rien ou des fonctions qui ne prennent aucun paramètres. void* permet aussi de déclarer un pointeur sur n'importe quel type de variables ou objet.
Langage : C et C++
Exemple et/ou commentaire :
Code : C++ - Afficher / masquer les numéros de lignevoid f(int a); //Fonction prenant un entier et ne renvoyant rien int g(void); //Fonction ne prenant aucun argument et renvoyant un int. int g(); //Cette écriture est identique à la ligne précédente
-------------------------------------------------------------------------------------------------------
N'hésitez pas si vous avez des remarques ou des suggestions
Édité
le 07/01/2008 à 09:24:54
par Nanoc
|
Tendou : Royaume de dieu
Groupe : Membres
|
|
Groupe : Membres
|
Merci pour ces nouveaux mots!
|
Apprenez à utiliser la STL !!
Groupe : Membres
|
|
Groupe : Membres
|
using permet d'importer des membres des classes héritées (s'utilise en conjonction avec les héritages non publics, et pour faire sauter les masquages ; traité dans la FAQ de developpez)
static sert aussi en C (et donc en C++) pour limiter la portée d'une variable ou d'une fonction à l'unité de traduction courante (1 .cpp + tous les .h inclus). En C++, on préfère les espaces de noms anonymes qui vont en plus s'appliquer sur des types.
On retrouve toujours ces notions de variable pseudo globale (dans le sens où elles vivent tout du long de l'application -- au détail des locales statiques qui naissent en cours de route)
(en vrai c'est le contraire dans la terminologie : les variables globales (-> extern), les données membres "static", et les variables locales "static" sont des données dites statiques (=> pas de rapport direct avec le mot clé "static"). Ce sont les portées d'accessibilité (façon de parler) qui changent)
|
Apprenez à utiliser la STL !!
Groupe : Membres
|
J'ai complété. Merci.
Juste une petite question. Ce que tu proposes pour static n'est-ce pas le comportement par défaut d'une variable "globale" (j'entends par là déclarée en-dehors de toute fonction) ?
|
Groupe : Membres
|
Voilà, je remonte un peu le sujet pour espérer d'autres définitions.  Merci de votre aide.
|
Mantis, Piranha, DeathAdder =)
Groupe : Membres
|
( un mini up caché  )
A noter qu'il y a une différence entre les boucles while et do while
Dans une boucle do while l'action sera effectué au moins une fois
|
Apprenez à utiliser la STL !!
Groupe : Membres
|
if, long, short et switch ne devraient pas poser de problèmes, je te fais ça demain.
Par contre les 3 derniers, (virtual,template, et surtout dynamic_cast) vont demander plus de réflexions.
EDIT: Les voilà:
if
Description : Mécanisme de branchement permettant d'exécuter du code selon différentes conditions. Le code correspondant à un test positif sera exécuté. Si le test est négatif et qu'une instruction else est présente, elle sera exécutée
Langage : C et C++
Exemple et/ou commentaire :
Code : C++ - Afficher / masquer les numéros de ligneif(/*Un test A*/) { //Code execute si le test A est vrai } else if(/*Un test B*/) { //Code execute si le test A est faux et que le test B est vrai } else { //Code execute si les tests A et B sont faux }
-------------------------------------------------------------------------------------------------------
switch
Description : L'instruction switch permet de tester une expression et d'exécuter différents portions de code en fonction de la valeur de l'expression. switch est très souvent utilisé à la place de multiples if-else if -else . L'expression testée doit renvoyer un int ou tout autre type de variabel assimiliable à un int
Langage : C et C++
Exemple et/ou commentaire :
Code : C++ - Afficher / masquer les numéros de ligneswitch(/*Un test renvoyant un int*/) { case 1: //Si le test a renvoye 1 //instructions correspondantes à ce cas break; case 2: case 3: //Instructions correspondantes aux cas où le test a renvoyé 2 ou 3 break; default: //Instructions correspondantes aux cas où le test a renvoyé n'importe quelle autre valeur }
-------------------------------------------------------------------------------------------------------
short
Description : Permet de déclarer une variable de type short int. On peut également déclarer des short double en combinant ces deux mots-clés.
Les variables short prennent moins de place en mémoire que les variables normales et peuvent par conséquent contenir des valeurs moins grandes.
Langage : C et C++
Exemple et/ou commentaire :
Code : C++ - Afficher / masquer les numéros de ligneshort a; //On déclare une variable de type short int short double b; //On déclare une variable de type short double
La norme ne définit pas de taille exacte pour les variables. Tout ce qui est précisé est que sizeof(short int) <= sizeof(int). Selon le type de votre processeur, les 2 types de variables peuvent très bien avoir la même longueur.
-------------------------------------------------------------------------------------------------------
long
Description : Permet de déclarer une variable de type long int. On peut également déclarer des long double en combinant ces deux mots-clés.
Les variables long prennent plus de place en mémoire que les variables normales et peuvent par conséquent contenir des valeurs plus grandes.
Langage : C et C++
Exemple et/ou commentaire :
Code : C++ - Afficher / masquer les numéros de lignelong a; //On déclare une variable de type long int long double b; //On déclare une variable de type long double
Certains compilateurs acceptent également des variables de type long long double permettant de contenir des valeurs encore plus grandes.
Remarque: La norme ne définit pas de taille exacte pour les variables. Tout ce qui est précisé est que sizeof (int) <= sizeof(long int). Selon le type de votre processeur, les 2 types de variables peuvent très bien avoir la même longueur.
-------------------------------------------------------------------------------------------------------
Édité
le 23/02/2008 à 11:45:54
par Nanoc
|
Groupe : Membres
|
|
Groupe : Membres
|
Ce n'est pas nécessairement plus. C'est au moins autant.
L'inégalité (sur les sizeof()) n'est pas stricte.
Au taf, int et long int ont la même taille.
|
Apprenez à utiliser la STL !!
Groupe : Membres
|
En effet, c'est mieux de le préciser.
Merci
|
Groupe : Membres
|
virtual
Description : Il permet de définir une fonction dans une classe de façon à ce qu'elle soit redéfinissable dans les classes filles, mot clé principal du polymorphisme.
Langage : C++
Exemple et/ou commentaire :
Code : C++ 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46 | class mere
{
public:
// fonction virtuelle pure OBLIGATOIREMENT REDEFINIE dans les classes filles
virtual void g() = 0;
// fonction virtuelle avec une implémentation par défaut
virtual void f() { std::cout << "mere::f()" << std::endl; }
// destructeur virtuel pour utiliser du polymorphisme
virtual ~mere() {}
};
class fille1: public mere
{
public:
virtual void g() { std::cout << "fille1::g()" << std::endl; }
virtual void f() { std::cout << "fille1::f()" << std::endl; }
virtual ~fille1() {}
};
class fille2: public mere
{
public:
virtual void g() { std::cout << "fille2::g()" << std::endl; }
virtual ~fille2() {}
};
int main()
{
mere* m1, m2, m3;
m1 = new mere; // erreur car mere contient la fonction f virtuelle pure
m2 = new fille1;
m2->f() // écrit "fille1::f()"
m2->g() // écrit "fille1::g()"
delete m2;
m3 = new fille2;
m3->f() // écrit "mere::f()" car f n'est pas redéfinie
m3->g() // écrit "fille1::g()"
delete m3;
return 0;
}
|
| fille1::f()
fille1::g()
mere::f()
fille2::g |
|
Groupe : Membres
|
(C'est le second mot clé principal du polymorphisme ... dit d'inclusion. Le premier incontournable est "public", c'est lui qui permet la substituabilité. "virtual" permet la spécialisation par supplantation.)
|
Apprenez à utiliser la STL !!
Groupe : Membres
|
J'ajouterai également qu'il manque l'utilisation de ce mot-clé pour faire hériter virtuellement une classe d'une autre dans le cadre d'une architecture "en losange" (c'est sûrement pas le terme consacré mais je ne le connais pas).
|
Choisir = se priver du reste.
Groupe : Membres
|
la liste des mos clés est visible dans le compilateur
Voila la mienne,
asm auto bool break case catch char class const const_cast continue default delete do double dynamic_cast else enum explicit export extern false float for friend goto if inline int long mutable namespace new operator private protected public register reinterpret_cast restrict return short signed sizeof static static_cast struct switch template this throw true try typedef typeid typename union unsigned using virtual void volatile while int8_t uint8_t int16_t uint16_t int32_t uint32_t int64_t uint64_t int_least8_t uint_least8_t int_least16_t uint_least16_t int_least32_t uint_least32_t int_least64_t uint_least64_t int_fast8_t uint_fast8_t int_fast16_t uint_fast16_t int_fast32_t uint_fast32_t int_fast64_t uint_fast64_t intptr_t uintptr_t intmax_t uintmax_t wint_t wchar_t wctrans_t wctype_t size_t time_t and and_eq bitand bitor compl not not_eq or or_eq xor xor_eq complex imaginary _Complex _Imaginary _Bool _Pragma
On peut en rajouter et en enlver si on le désire.
Si quelqu'un vous dit : "Je me tue à vous le répéter", laissez-le mourir.
Chef du fan club de jaloyan1
|
Groupe : Membres
|
Beaucoup sont des extensions propriétaires à ton compilo.
|
Groupe : Membres
|
Salut,
restrict
Description :
Dit d'un pointeur que la zone pointée n'est pointée que par lui.
Cela permet au compilateur de faire certaines optimisations.
Langage : C et C++
Exemple et/ou commentaire : N/A
typeof
Description :
Permet d'obtenir le type d'une variable
Langage : C++
Exemple et/ou commentaire :
Code : C++1
2
3
4 | int a;
typeof(a) b; // correspond à int b
double c = 1;
typeof(a+c) d; //correspond à double d
|
Permet de contenir un int ou un pointeur
Langage : C++/C
Exemple et/ou commentaire :
Avec les machines 64 bits, 32 bits, etc... les pointeurs ou les int peuvent prendre plus de place en mémoire l'un que l'autre. intptr_t est un type qui est au moins aussi grand que chacun et permet quelque soit l'environnement de contenir un pointeur ou un int.
|
Apprenez à utiliser la STL !!
Groupe : Membres
|
Ce ne sont pas des mots-clés officiels du langage mais des extensions offertes par certains compilateurs.
|
Groupe : Membres
|
Il reste que trois mots clefs :
-> dynamic_cast,
-> template,
-> virtual.
@coyotte508 : merci quand même  .
|
Apprenez à utiliser la STL !!
Groupe : Membres
|
Citation : hiuraIl reste que trois mots clefs :
-> dynamic_cast,
-> template,
-> virtual.
Si il fallait prendre des paris sur ce qui manque, j'aurais presque dit ceux-là. Ils impliquent tellement de choses que c'est dur de résumer.
|
Groupe : Membres
|
Oui, et le but n'étant pas de faire un cours...
|
Tendou : Royaume de dieu
Groupe : Membres
|
j'aimerais apporter une precision sur typeid
CitationDescription : Opérateur qui renvoie une référence sur un type_object, un objet qui décrit l'objet passé en argument.
plus precisement, typeid renvoie une reference (constante ?) sur un objet std::type_info
|
Groupe : Membres
|
|
Tutoriels
Communauté
Mon compte
Recherche
Livre d'or
Publicité
MatteX
245 Zéros connectés |
7 requêtes |
0.0293s (0.0114s)
