Discussion :

[dfshr8]

Bonjour,


Je ne comprends pas bien ce qu'est la "standard library".

1) Apperement on recommende de toujurs écrire std::cout, au lieux de mettre en début: include namespace.... Si j'ai bien compris cout est un objet de la librairie standard que l'on peut utiliser seuleement grçace au fichier d'entête iostream. Dans le cas où l'utilisateur défiit lui même une fonction/objet cout (donc un homonyme), on doit préciser si n utilise celui de iostream ou celui de l'utilisateur (d'où le besoin de préciser std (celui définit par la librairie standard). Ai je bien compris ?

2)Je ne comprens pas les chevrns << après cout. Il semble qu'il s'agisse d'"opérateurs" ( unpeu comme l' addition + qui est un "opérateur binaire" puisqu'il agit sur deux variables). std::cout << signifie t il que << est un opérateur unaire qui agit à droite de l'objet cout (qui est donc l'opérande)?

3) Si je retourne 1 au lieu de 0 dans le main est ce un soucis ? car c'est bin un entier donc ça semble logique aussi

4)Qu 'est ce que le "core language" ? d'aprèsle bouquin que je suis (accelerated c++, que je complète ave c++ for mathematicians et c++ par la pratique, j'espère que ce sont de bonnes réferences) il est mentionnée que le "core language est disponible sur tous les programme c++". Je ne comprends pas bien ce que ca signifie...

[dfshr8]

5) Apperement on distingue:
- les "expressions" comme

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

cout<<"g"<< endl

qui 'compute' quelquechose (un résultat et peuvent avoir un "side effect" à l' écran). Apperement c'est composé d'opérateurs (opérateurs mathématiques usuels, chevrons <<,...) [on pourrait les remplacer par des fonctions], et opérandes (variables x,donnée comme le chiffre 1, objet) .
Tous les opérandes ont un type: l'objet cout est de type ostream, 1 est de type int.... Un type

[ternel]

Bonnes questions.

C++ est un langage.

Comme tout langage il requiert un vocabulaire minimal (que j'appelle primitif), c'est l'ensemble des mots-clés, des types primitifs et des opérateurs agissant sur ceux-ci.
La norme (qui est aussi un traité ) définit la syntaxe et la grammaire de ce langage.
Le langage fournit ainsi plusieurs moyens pour étendre le vocabulaire.

La norme prévoit aussi un vocabulaire de base, qui est la bibliothèque standard. (et pas librairie)
Il s'agit d'un ensemble de choses définies au moyen du langage.
Par exemple, le code de std::string est intégralement disponible dans <string> (et ses inclusions).



Le namespace est un outil qui permet de regrouper diverses choses sous un certain préfixe.
Comme tu l'as assez bien décrit, std::cout est une variable (cout) déclarée dans le namespace std.

using permet d'importer des noms dans un namespace commun (au domaine d'origine du nom et le domaine courant).

1) ton analyse est la bonne, les espaces de noms permettent de limiter les cas d'interférence entre les bibliothèques.
Concernant la recommandation, la posture normale est:
Aucun using namespace dans un en-tête (un header, .h ou .hpp)
Cela, parce que ce using sera inclus sans le savoir par tout code qui utiliserait l'en-tête.

Par contre, un using sur un type particulier (comme using std::vector) peut apparaître dans la déclaration d'une classe.

Pour les fichiers d'implémentation, c'est à toi de voir.
Dans l'implémentation d'un vecteur (au sens mathématique), je n'utiliserais certainement pas using std::vector, mais dans d'autre cas, pourquoi pas.

2) << est initialement un opérateur binaire, qui calcule un décalage à gauche (left shift).
Ainsi, 2 << 3 vaut 16, car 2 s'écrit 0000000010 et qu'en décalant les bits de 3 vers la gauche, on obtient 0000010000.

Le modèle de classe std::basic_ostream<...> (dont hérite la classe dont std::cout est un objet) surcharge cet opérateur.
Ainsi, std::basic_ostream<...>::operator<<(double) est une fonction membre.

L'un des moyens d'étendre le vocabulaire du C++ est justement de surcharger les opérateurs pour certaines classes.
Par exemple, les classes std::vector et std::map surchargent l'opérateur [] (chacune à sa façon).

3) la valeur de retour de main est (ou n'est pas, la norme ne l'impose pas) utilisé comme code d'exécution du programme.
Comme a priori il n'y a qu'une manière de réussir et plein de se tromper, la coutume veut qu'on utilise 0 pour la réussite du programme et tous les autres entiers pour les erreurs.
Ca n'empêche pas que ton programme fait bien ce qu'il veut avant de retourner.

Concrêtement, pour le C++, tu peux retourner la valeur qu'il te plait.
Voire même, il est possible pour la fonction main (et uniquement celle-ci) de ne pas faire de return explicitement, car il sera ajouté en cas de besoin par la compilation.
Dans ce cas particulier, je ne sais plus ce que C++ demande ou suggère comme valeur. J'imagine cependant que ce sera 0.

4) Le "core language" ou "langage pur", c'est le langage sans sa bibliothèque standard.
Il s'agit du vocabulaire primitif et de la grammaire.
Pour résumer succintement, c'est ce qui est disponible sans utiliser #include.


5) une instruction est exécutée. une expression est une opération produisant une valeur.
Il existe trois grands genres d'instructions:
les déclarations: un type, un nom et éventuellement une valeur (int a = 2; ou int f(int i) {return 2*i})
les instructions-expressions: c'est à dire une expression suivie d'un point-virgule.
les instructions de controle comme if ou while.

[dfshr8]

Merci pour ces réponses précises et très instructives.
6) Je ne coprends pas bien cette portion de cour:
"The input operation has another side effect: It causes our prompt, which asks for the user's
name, to appear on the computer's output device. In general, the input-output library saves
its output in an internal data structure called a buffer, which it uses to optimize output
operations. Most systems take a significant amount of time to write characters to an output
device, regardless of how many characters there are to write. To avoid the overhead of
writing in response to each output request, the library uses the buffer to accumulate the
characters to be written, and flushes the buffer, by writing its contents to the output
device, only when necessary. By doing so, it can combine several output operations into a
single write."

[Bousk]

En gros y'a un buffer interne pour pas avoir à faire un flush à chaque fois vers la sortie, opération longue. Et tu flush tout une fois à la fin.

[ternel]

Voici une version imagée:
Le processeur est à quelques centimètres de la RAM.
Le processeur est à environ un mètre de l'utilisateur (plus, en longueur de fil).
Il est donc a priori cent fois plus rapide d'accéder à un bloc mémoire qu'à l'utilisateur.

Partant de ce constat, les affichages et saisies sont faites au travers d'un bloc mémoire interne (un buffer) de la manière suivante:

• En sortie: On écrit quand on veut, l'OS l'affiche quand il peut, et quand on l'exige, on peut s'arreter pour attendre que l'ordinateur l'affiche (flush the buffer)
• En lecture: L'utilisateur quand il veut, l'OS nous le transmet quand il le veut, nous, on l'attendra.

C'est très imagé, à moitié faux, mais ca explique le problème.
En réalité, le problème, c'est de convertir un caractère en pixels à l'écran.
Et c'est d'autant plus difficile que l'interface graphique est puissante.

[dfshr8]

Je suis désolé mais j'ai du mal à bien comprendre...
Si je combine vos deux répnses (enfin ce que j'en comprends): on veut limiter les "flushs" qui prennent trop de temps. Pour celà on va essayer d'optimiser l'utilisation du buffeur lors des ecritures/lectures.

Pour bien expliquer l' ensemble du prblème voici le paragraphe complet:

"The input operation has another side effect: It causes our prompt, which asks for the user's
name, to appear on the computer's output device. In general, the input-output library saves
its output in an internal data structure called a buffer, which it uses to optimize output
operations. Most systems take a significant amount of time to write characters to an output
device, regardless of how many characters there are to write. To avoid the overhead of
writing in response to each output request, the library uses the buffer to accumulate the
characters to be written, and flushes the buffer, by writing its contents to the output
device, only when necessary. By doing so, it can combine several output operations into a
single write.

There are three events that cause the system to flush the buffer. First, the buffer might be
full, in which case the library will flush it automatically. Second, the library might be asked
to read from the standard input stream. In that case, the library immediately flushes the
output buffer without waiting for the buffer to become full. The third occasion for flushing
the buffer is when we explicitly say to do so.

When our program writes its prompt to cout , that output goes into the buffer associated
with the standard output stream. Next, we attempt to read from cin . This read flushes the
cout buffer, so we are assured that our user will see the prompt.

Our next statement, which generates the output, explicitly instructs the library to flush the
buffer. That statement is only slightly more complicated than the one that wrote the prompt.
Here we write the string literal "Hello, " followed by the value of the string variablename , and finally by std::endl . Writing the value of std::endl ends the line of output,and then flushes the buffer, which forces the system to write to the output stream
immediately.

Flushing output buffers at opportune moments is an important habit when you are writing
programs that might take a long time to run. Otherwise, some of the program's output
might languish in the system's buffers for a long time between when your program writes it
and when you see it"

Moi j' en comprends :
- A chaque cout le tampn se vide au moment ou le texte s'affiche sur l' écran
- Lors d'un cin, là je ne sais pas trop... Car il faut le temps au pc de lire ce qui est tapé puis de le stoker dans une variable....

7) Quel différence entre char et string ? Ce sont évidement deux types différents, mais char ne représente t'il qu'un seul caractère alors que string est une suite de caractères ?

[ternel]

char est un caractère unique, c'est aussi un type primitif.
char* est un pointeur de char, c'est aussi le type utilisé en C référer à une suite continue de char, terminée par un '\0' qui est le caractère nul.
std::string est une classe standard garantissant de ne pas faire de bêtise avec la mémoire (sauf à le faire exprès).

Pour les deux buffers, en gros, il permettent de ne pas payer le coût d'accès à l'écran/le clavier pour à chaque fois.

Par exemple, si ton programme contient ceci:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
std::cout << "veuillez saisir trois nombre " << std::endl;
int a, b, c;
std::cin >> a >> b >> c;

Alors à l'exécution, après l'affichage, l'utilisateur est attendu.
Il peut par exemple taper ceci: "1 2<entrée>3"

cin >> a >> b >> c; est évalué ainsi:

• cin >> a qui retourne (une référence sur) cin
• cin >> b qui retourne cin
• cin >> c qui retourne cin
• puis rien de plus, car on arrive au point-virgule. C'est un exemple d'instruction-expression. Seul ses effets de bord sont intéressant, car la valeur est abandonnée.

la première partie s'arrête jusqu'à ce que le buffer soit assez rempli.
Concrètement, l'OS va attendre jusqu'à ce que l'utilisateur appuie sur <entrée> ou provoque une fin de fichier (EOF, Ctrl+D avec un linux).

voici ce qui se passe:
avant l'étape 1: a, b et c valent "random: mémoire non initialisée", le buffer est vide.
durant l'étape 1:
le buffer étant vide, le programme rend la main à l'OS
l'utilisateur commence à taper. En appuyant sur la touche <entrée>, il signale à l'OS que le buffer est assez rempli.
le buffer contient "1 2\n"
cin parvient à lire un int, qu'il retire du buffer, et assigne 1 à a.
le buffer contient finalement " 2\n"

étape 2:
le buffer n'est pas vide, cin cherchant un int, il saute les éventuels caractères blancs (espace, tab, \n ...), arrivant devant 2.
Il lit cet int, et l'affecte à b (2).
le buffer contient "\n".

étape 3:
le buffer n'est pas vide, cin cherchant un int, il saute les éventuels caractères blancs (espace, tab, \n ...), vidant ainsi le buffer.
le programme rend la main à l'OS, qui continue alors à écouter l'utilisateur.
celui-ci finit sa saisie: "3"
tant qu'il n'a pas appuyé sur <entrée> ou provoqué une fin de fichier, l'OS attend sagement.

Voila pour la mécanique du buffer d'entrée.
Si au lieu de saisir "3", l'utilisateur appuie de suite sur <entrée>, cin ne trouve rien à lire, mais comme il n'est pas sur un cas d'erreur, il demande encore la suite à l'OS.
Enfin, si l'utilisateur ne saisi toujours pas de nombre, mais provoque enfin une fin de fichier, cin ne donnera pas de valeur à c, mais se marquera en erreur.

chose que tu pourras vérifier avec if(cin), voire meme avec une instruction combinée:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
if (!(cin>>c)) {
    cout << "le troisième nombre n'a pas été lu" << endl;
}

C'est précisément ce qu'on fait quand on lit un fichier.

[dfshr8]

Rha mais merci mille fois! Pour être sûr d'avoir bien compris:
http://mathalope.co.uk/2014/06/22/ac...-exercise-1-6/

Partie facultative (car je crois que finalement j'ai bien compris tes explications encore merci):

(

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
What does the following program do it, when it asks you for input, you type two names (for example, Samuel Beckett)? Predict the behaviour before running the program, then try it.
 
 
#include <iostream>
#include <string>
 
int main()
{
    std::cout << "What is your name? ";
    std::string name;
    std::cin >> name; // frist std::cin step
    std::cout << " Hello, " << name
                << std::endl << "And what is yours?";
    std::cin >> name;  // second std::cin step
    std::cout << "Hello, " << name
                << "; nice to meet you too!" << std::endl;
    return 0;
 
}

Le fait d'entrer : Mathieu Cheddid par exemple (donc avec un espace dans le premeir cin comment est géré cet espace ?)

En attendant je vais relir vos explications pour être sûr de bien tout assimiler, encore merci!!

[dfshr8]

7) Je ne comprends pas bien le " second idea ": notemment cet invariant... est cela condition qui stoppe le while ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
There is a useful technique for writing and understanding while statements that relies on
two key ideas-one about the definition of a while statement, and the other about the
behavior of programs in general.
 
The first idea is that when a while finishes, its condition must be false -otherwise the
while wouldn't have finished. So, for example, when the while in §2.3/19 finishes, we
know that r != rows is false and, therefore, that r is equal to rows .
 
The second idea is that of a loop invariant, which is a property that we assert will be true
about a while each time it is about to test its condition. We choose an invariant that we
can use to convince ourselves that the program behaves as we intend, and we write the
program so as to make the invariant true at the proper times. Although the invariant is not
part of the program text, it is a valuable intellectual tool for designing programs. Every
useful while statement that we can imagine has an invariant associated with it. Stating the
invariant in a comment can make a while much easier to understand.

[picodev]

Bonjour,

Les invariants de boucle sont un outil pour prouver la correction d'un programme. Un invariant de boucle est une proriété vraie avant la boucle, à chaque tour de boucle et à la sortie de boucle.
Un exemple trivial serait pour une boucle qui calcule une somme d'entiers comme :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
int somme(int n) {
  int i=0;
  int s=0;
  while (i<n) {
    i = i + 1;
    s = s + i;
  }
  return s;
}

On définit l'invariant I comme «s contient la somme des entiers de 0 à i».
Avant la boucle I est vraie car la somme des entiers de 0 à 0 vaut 0 et s vaut 0.
À chaque tour de boucle s contient la somme des entiers de 0 à i-1, on lui rajoute l'entier i ; donc s contiendra la somme des entiers de 0 à i : I reste vraie.
À la sortie de la boucle ii vaut n et s contient la somme des entiers de 0 à n. I reste vraie et cela nous permet de prouver que cette boucle calcule bien la somme des entiers de 0 à n.

[dfshr8]

Je ne comprends pas bien... On peux définir une infinité d'invariant de boucles (même des choses qui n'ont aucun rapport avec le programme, il suffit d'énoncer une propriété vrai (au sens mathématique par exemple)).


PS: J'ai vu que l' ouvrage accelerated c++ est chaudement reommendé mais j butte beaucoup dessus. L'objectif de mon apprentissage C++ est de dévelloper un petit logiciel de calcul (élément finis) dans le cadre d'un mémoire de fin d'étude. Je penses à l'alternative "C++ for mathematicians" ( de Scheinerman) qui est déstiné aux mathématiciens. N'ayant aucun recul sur les deux ouvrages je sollicite vos conseils (pour ceux qui auraient consultés les deux ouvrages)

[picodev]

En effet, il y en a beaucoup. Mais il y en a peu qui soit intéressantes, parmi celles-ci il y a celles qui nous permettent de prouver que la boucle fait exactement ce qu'on lui demande, ni plus ni moins. Trouver un invariant de boucle est parfois compliqué et «ne sert qu"à prouver une correction».
D'une manière générale on ne se préoccupe pas de formaliser tout ça en codant car on dispose de tout un tas de recettes qui nous assurent de la correction., de la terminaison, ... (pour tel type de problèmes on utilise tel algorithme en l'implémentant de telle façon).

[white_tentacle]

Je ne comprends pas bien... On peux définir une infinité d'invariant de boucles (même des choses qui n'ont aucun rapport avec le programme, il suffit d'énoncer une propriété vrai (au sens mathématique par exemple)).

Oui. Globalement, l’idée est de définir un invariant qui a un sens, et qui est facilement vérifiable, qui permet de détecter un éventuel bug dans un programme, qui porte sur le contenu de la boucle.

Mais à part ça… certains (dont je fais partie, tu l’auras deviné) trouvent que cette notion n’est franchement pas top et ne sert pas à grand chose. Plus utile est le variant de boucle : une propriété qui décroît à chaque itération de la boucle : cela permet de garantir la terminaison. Dans l’exemple de picodev, le variant serait le nombre d’entiers restant à traiter.

[dfshr8]

8) J'ai vu que l' ouvrage accelerated c++ est chaudement reommendé mais je butte beaucoup dessus. L'objectif de mon apprentissage C++ est de dévelloper un petit logiciel de calcul (élément finis) dans le cadre d'un mémoire de fin d'étude. Je penses à l'alternative "C++ for mathematicians" ( de Scheinerman) qui est déstiné aux mathématiciens. N'ayant aucun recul sur les deux ouvrages je sollicite vos conseils (pour ceux qui auraient consultés les deux ouvrages)

[ternel]

Toi, tu es en train d' "apprendre à programmer en C++"
En fait, tu fais deux choses à la fois: "apprendre à programmer" et "apprendre à coder en C++"

La première chose s'appelle classiquement algorithmie, et c'est dans ce sujet qu'on traite de boucle, d'invariants, du problème de terminaison et de complexité (algorithmique).

Le second apprentissage n'a presque rien à voir, il s'agit d'apprendre une manière de mettre en oeuvre les beaux principes de l'algorithmie.
C'est là qu'on parlera de valeur de retour de main(), de référence constante, et de tous ces détails du langage.

Tu t'en doutes, apprendre correctement le C++ suppose qu'on sait programmer, c'est à dire décrire un programme.

Voici comment je résumerai "programmer":
C'est l'art de choisir décrire des données et de savoir manipuler ces descriptions.
L'un des enjeux, c'est de trouver la bonne représentation pour que les opérations soient simple à décrire.

Partant de là, tes deux livres ne remplissent pas du tout le même rôle, et j'ai un peu peur qu'ils ne te présentent que le vieux style du C++.

N'hésite surtout pas à nous montrer ton code quand il te pose problème.

N'hésite pas non plus à prendre le temps de faire des programmes jouets.
Pour en trouver, cherche "exercice" ou "projet" sur le forum, ou dans la section débuter.
Ca te donneras des tas de sujets.

[dfshr8]

Merci beaucoup! (tes messages sont toujours très motivants pour poursuivre même si apprendre le C++ et la programmation en autodidacte n'est pas aisée!).

Quels livres (de préférence en Français) conseillerais tu ?

Pour apprendre l'algorithmique je me me réfère à débuter en algorithmique de Cormen,.... Mais je ne comprends toujours pas les invariants de boucles...

PS: Pour les ouvrages C++ je me suis fié au site sérieux suivant:
http://www.developpez.net/forums/d14...ng-by-example/
http://cpp.developpez.com/livres/ind...us#L020170353X

[dfshr8]

10) C'est à n'y rien comprendre. Je lis le prmier chapitre du livre et ils ne disent me pas ce qu'st un pointeur...


Bon après lecturesur le web je comprends à peu près ce que l'auteur énonce. x=y (nos deux poineurs x et y sont les mêmes et ils pointnt tous les deux vers un même emplacement mémoire contenant les attributs et méthodes de l'objt consdéré.

[koala01]

Salut,

Un petit conseil avant de commencer : ne te butte pas sur la (non) compréhension d'un seul terme. Le plus souvent, les choses finissent souvent par s'éclairer d'elles-mêmes "quand toutes les notions sont présentes"

Mais, de manière générale, chaque fois que tu vas coder un fonction (ou une application ou un (morceau de) programme ), tu vas essayer d'établir un "contrat" entre "toi" (celui qui développe la fonctionnalité) et "l'utilisateur" (celui qui va utiliser la fonctionnalité). Ce contrat est finalement assez simple et se résume peu ou prou à "donne moi des données cohérentes, tu obtiendras un résultat prédictible et clairement défini".

Les notions de préconditions, de postconditions et d'invariants sont les notions qui nous permettent de définir les droits et les obligations de chaque intervenant dans ce contrat : le droit de l'utilisateur est d'avoir un résultat correct, mais il va de paire avec l'obligation de fournir des données cohérentes. Quant au devoir du développeur, c'est de veiller à ce que la fonctionnalité réagisse exactement de la manière dont on s'y attend, mais, pour arriver à ce résultat, il faut que les données qu'on fournit à cette fonctionnalité soient cohérentes.

Pour que le contrat fonctionne, il faut que certaines conditions soient remplies. On peut donc distinguer trois sortes de conditions :

• les conditions qui doivent être remplies en préambule à toute tentative de travail : on parle de pré-conditions(ex : si tu veux que je lise le contenu d'un fichier, il faut que tu m'indiques le nom de ce fichier)
• les conditions qui doivent être remplies après que le travail ait été fait : on parle de post-conditions(ex : tu m'as demandé de charger une liste de client... quand le travail a été fait, tu dois avoir une liste de clients n'est pas vide).
• les conditions qui doivent être remplies en permanence : on parle d'invariant( ex : un carré a quatre coté égaux : si une forme n'a pas quatre cotés ou que les quatre cotés ne sont pas égaux, on ne peut pas estimer qu'il s'agisse d'un carré).

En simplifiant, nous pourrions dire que le respect des pré-conditions dépend exclusivement de l'utilisateur d'une fonctionnalité (il doit veiller à ce que les données qu'il fournit soient cohérentes) et que le respect des post-conditions dépend exclusivement du développeur d'une fonctionnalité (il doit veiller à ce que le système soit dans un état cohérent après avoir effectué ce que l'on attend de sa part).

Si, pour une raison ou une autre, le système n'est pas capable de se retrouver dans un état cohérent, il y a rupture du contrat, et tout peut alors arriver. Généralement, nous testerons les préconditions avant même d'effectuer le moindre traitement, le plus souvent sous la forme d'assertions. Par contre, si le système est dans l'impossibilité, malgré le fait que les pré-conditions étaient remplies, de se retrouver dans un état cohérent après avoir terminé le traitement, on choisira généralement de lancer une exception pour indiquer qu'il y a eu un problème.

Enfin, le compilateur s'avère souvent être d'une aide particulièrement efficace pour le respects des invariants. Un invariant que l'on tend à utiliser énormément est, pour te donner un exemple concret, la constance des objets: on peut dire qu'une donnée ne peut en aucun cas être modifiée (dans un contexte particulier, s'entend). Si l'on déclare cette donnée comme étant constante, le compilateur est parfaitement en mesure de s'assurer qu'elle ne sera effectivement jamais modifiée, et te fera savoir de manière cinglante que tu essayes de la modifier alors que tu n'en as pas le droit

Ainsi, la notion d'invariant de boucle n'est rien d'autre que la notion d'invariant (autrement dit, une condition qui doit être remplie en permanence) appliquée au cas particulier d'une boucle d'exécution s'effectuant plusieurs fois et qui, par conséquent, devra être vérifiable à chaque fois que l'on rentrera (ou que l'on sortira) de la boucle.

Alors, bien sur, on peut absolument mettre les conditions que l'on veut où l'on veut, dans les circonstances que l'on veut. Mais une condition (comme beaucoup de choses en informatique) ne vaut d'être exprimée que si elle a du sens et si elle est susceptible d'être utilisée et vérifiée. Tout le travail du développeur consiste à trouver les conditions qui méritent d'être vérifiées afin de fournir l'assurance que nous obtiendrons effectivement le résultat auquel nous sommes en droit de nous attendre

[dfshr8]

11) J'ai essayé d'inplémenter tri insertion (trouvé dans le livre algorithmique):
a) Est ce que la manière dont je code est correcte (indentation,...)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
//Tri par insertion de Tab [6]= {5,4,2,6,1,3};
 
#include <iostream>	
using namespace std;
 
int main(){
	int Tab [6]= {5,4,2,6,1,3}; // Pour simplifier on insère un tableau exemple
	int longueur_Tab=sizeof(Tab)/sizeof(int) ;// 
	int j;//première boucle variable 
	int i;//seconde boucle variable parcours la main gauche
 
	for (j=1,j==longueur_Tab,j++){ //l'indice j indique la carte courante en cours d'insertion
 
		//on prend la carte et on la conpare à nos carte dans la main gauche
		cle=Tab[j]; // on stocke en mémoire la valeure de la carte courante que l'on eut insérer
		i=j-1; //on se place au dernier élément de la main gauche 
 
		while (i>0 and cle<Tab[i]) { //Si 
			Tab[i+1]=Tab[i];// On décale vers la gauche, 
			i=i-1;
			}
		Tab[i+1]=cle;
 
		}
 
	return 0;
}

b) il y a pas mal d'erreurs de compilation mais je ne les voit pas:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
g++ tri_ins.cpp -o tri_ins
tri_ins.cpp: In function ‘int main()’:
tri_ins.cpp:12:30: error: expected ‘;’ before ‘)’ token
  for (j=1,j==longueur_Tab,j++){ //l'indice j indique la carte courante en cours d'insertion
                              ^
tri_ins.cpp:30:1: error: expected primary-expression at end of input
 }
 ^
tri_ins.cpp:30:1: error: expected ‘;’ at end of input
tri_ins.cpp:30:1: error: expected primary-expression at end of input
tri_ins.cpp:30:1: error: expected ‘)’ at end of input
tri_ins.cpp:30:1: error: expected statement at end of input
tri_ins.cpp:30:1: error: expected ‘}’ at end of input

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
//Tri par insertion de Tab [6]= {5,4,2,6,1,3};
 
#include <iostream>	
using namespace std;
 
int main(){
	int Tab[6]= {5,18,2,8,3,3}; // Pour simplifier on insère un tableau exemple
	int longueur_Tab=sizeof(Tab)/sizeof(int) ;// 
	int j;//première boucle variable 
	int i;//seconde boucle variable parcours la main gauche
	int k;
	for (j=1;j<longueur_Tab;j++){ //l'indice j indique la carte courante en cours d'insertion
		int cle;
		//on prend la carte et on la conpare à nos carte dans la main gauche
		cle=Tab[j]; // on stocke en mémoire la valeure de la carte courante que l'on eut insérer
		i=j-1; //on se place au dernier élément de la main gauche 
 
 
		while (i>=0 and cle<Tab[i]) { //Si 
			Tab[i+1]=Tab[i];// On décale vers la gauche, 
			i=i-1;
			}
 
		Tab[i+1]=cle;
 
		}
 
	for (k=0;k<longueur_Tab;k++){
		cout<<Tab[k]<<endl;
	}
 
 
	return 0;
}