Je suis débutant en développement. Je voudrais savoir si vous pourriez m'aider.
Tout d'abord l'exercice : , je veux créer deux nouveaux tableaux qui contiendront, pour le premier les nombres pairs uniquement, pour le second les nombres impairs.
Je n'arrive pas à afficher les tableaux pairs et impairs. Donc, si vous pourriez m'aiguiller ce serait pas mal
Voici mon code :
///////////////////////////////////////////////////////////////////////////////////////////////////////////
int main()
{
vector<int> const tableau{ 1, 2 , 3 , 4 , 5 ,6, 7 ,8 ,9 ,10 };
int i,Pcmp(0), Icmp(0);
std::vector<int>P{};
std::vector<int>I{};
cout << "Je vais afficher mon tableau en entier" << endl;
for (auto const tableau : tableau)
{
cout << tableau << std::endl;
}
for (i = 0; i < 10; i++)
{
if (tableau[i] % 2 == 0)
{
P[Pcmp] = tableau[i];
Pcmp++;
}
else
{
I[Icmp] = tableau[i];
Icmp++;
}
return 0;
}
cout << " Les elements pairs du tableau sont" << P << endl;
cout << " Les elements impairs du tableau sont" << I << endl;
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////
Tu es certain que ça compile? Pas de fichier include ? Pas de std:: pour le vecteur tableau Si tu ne connaissais pas la longueur du tableau d'origine à la compilation, tu ferais quoi? Si le tableau d'origine avait une longueur de 10000, pas certain que ça ne planterait pas ... Tu peux afficher les vecteurs de sortie comme le vecteur d'entrée.
Le Tout est souvent plus grand que la somme de ses parties.
Anonyme
7 février 2023 à 19:10:28
- Message modéré pour le motif suivant : Merci d’utiliser le bouton code pour inséré un code sur le forum
Je reposte votre code en signalant les éléments cités par @bacelar et @PierrotLeFou. Comme il y a pas mal de problèmes j'écris directement en commentaire dans le code. À vous de faire les modifications nécessaires.
//Pour utiliser la classe vector et les sorties console il faut les bons includes
//#include <vector>
//#include <iostream>
int main()
{
vector<int> const tableau{ 1, 2 , 3 , 4 , 5 ,6, 7 ,8 ,9 ,10 };
int i,Pcmp(0), Icmp(0); //Ces 3 déclarations sont inutiles.
std::vector<int>P{};
std::vector<int>I{};
cout << "Je vais afficher mon tableau en entier" << endl; //Manque l'espace de nom de la librairie standard "std::"
//ça donnerait plutôt "std::cout" et "std::endl"
for (auto const tableau : tableau) //Ici le tableau et un de ses éléments ont le même nom,
//cela va poser problème...
{
cout << tableau << std::endl; //attention au std::
}
for (i = 0; i < 10; i++) //On peut déclarer le i directement dans le premier champ : "for(unsigned i{0};..."
{
if (tableau[i] % 2 == 0)
{
P[Pcmp] = tableau[i]; //plutôt P.push_back(tableau[i]); sinon,
//vous essayez de modifier un élément qui n'existe pas encore
Pcmp++; //Le push_back rend cette variable inutile.
}
else
{
I[Icmp] = tableau[i]; //mêmes choses ici
Icmp++;
}
return 0;
}
cout << " Les elements pairs du tableau sont" << P << endl; //P est un std::vector<int>
//le c++ ne sait pas afficher cela,
//il faut faire comme pour tableau plus haut...
//attention aux std::
cout << " Les elements impairs du tableau sont" << I << endl; //Mêmes choses.
}
Voilà, n'hésitez pas à poster à nouveau si cela ne compile toujours pas... Utilisez le bouton </> du forum pour mettre en forme votre code.
Le message qui suit est une réponse automatique activée par un membre de l'équipe de modération. Les réponses automatiques leur permettent d'éviter d'avoir à répéter de nombreuses fois la même chose, ce qui leur fait gagner du temps et leur permet de s'occuper des sujets qui méritent plus d'attention. Nous sommes néanmoins ouverts et si vous avez une question ou une remarque, n'hésitez pas à contacter la personne en question par Message Privé. Pour plus d'informations, nous vous invitons à lire les règles générales du forum
Merci de colorer votre code à l'aide du bouton Code
Les forums d'Openclassrooms disposent d'une fonctionnalité permettant de colorer et mettre en forme les codes source afin de les rendre plus lisibles et faciles à manipuler par les intervenants. Pour cela, il faut utiliser le bouton de l'éditeur, choisir un des langages proposés et coller votre code dans la zone prévue. Si vous utilisez l'éditeur de messages en mode Markdown, il faut utiliser les balises <pre class="brush: cpp;">Votre code ici</pre>.
Merci de modifier votre message d'origine en fonction.
Je voudrais vous expliquez ce que j'ai compris et dites moi s'il vous plait, si vous n'avez rien compris , n'hésitez pas à me critiquer. Toute critique est bonne à prendre.
Donc, voici mon explication :
Tout d'abord , j'ai créé un tableau contenant des valeurs.
Ensuite , j'ai créé deux tableaux , le premier tableau est un tableau qui se nomme "P" et un tableau qui se nomme "I".
Le tableau P contiendra les nombres pairs et le tableau "I" contiendra les nombres impairs.
Donc, ce que je voulais faire d'abord c'est d'afficher mon tableau entier.
Ensuite , je vais ajouter dans le tableau pair si le reste de la division est égale à 0 sinon dans le tableau impair et ensuite on affiche les tableaux.
Oui c'est cela. Pour moi c'est parfait. Je n'ai rien à redire, sauf les lignes 11 et 13. Oui cela compile, mais il y a deux choses très différentes qui portent le même nom "tableau". Je pense qu'il faudrait éviter cette confusion. Ligne 17, le problème est un peu le même, "tableaux" est mal choisi pour désigner un simple élément... EDIT: dernière chose (un détail). Il faut essayer d'être plus cohérent et raisonnable avec les sauts de ligne. Choisir quelques règles et s'y tenir.
Oui, "tableau : tableau", ça va trop loin je trouve Coder avec une synthèse doit être très difficile. Comment fait-elle pour lire les signes et mots étranges des langages de programmation ? Est-ce qu'elle épelle chaque caractère ? En plus la pensée est moins linéaire que dans un texte, on a tendance à sauter des lignes, revenir en arrière, penser par bloc...
@Demshay
L'idée c'est qu'il faut choisir des noms de variable explicites, autant que possible, pour que tout le monde puisse s'y retrouver.
@Deedolith: > Une seul lettre ? Non !!! C'est nul !!! Je suppose que tu as compris que c'était intentionel ... @Umbre37: Je peux lire une ligne à la fois, ou un "mot" à la fois, ou un caractère à la fois. Elle me donne presque tous les caractères quand je lis par ligne, et "tous" les caractères quand je les lis un caractère à la fois. Une chance que j'ai une bonne mémoire. J'ai déjà vu et je sais ce que représente que de voir tout un écran d'un seul coup.
Le Tout est souvent plus grand que la somme de ses parties.
D'abord, en ce qui concerne le choix des noms de variables, je dirais déjà que, le SRP aidant, chaque variable ne devrait servir qu'à une seule et unique chose et que plus une variable est utilisée loin de sa déclaration, plus il est intéressant que son nom soit long, de manière à ce qu'il soit le plus explicite possible.
Mais ce n'est pas vrai que pour les variables, ce l'est aussi pour les types de données et pour les fonctions
Ainsi, si tu déclares trois tableaux, qui sont respectivement destinés à contenir l'ensemble de toutes les valeurs sans distinction, uniquement les valeurs pairs d'une part et uniquement les valeurs impaires de l'autre, leur nom devrait être suffisamment explicite que pour représenter leur utilité, par exemple (je vais les nommer en anglais, par habitudes )
int main(){
std::vector<int> allNumbers{1,2,3,4,5,6,7,8,9,10};
std::vector<int> evenNumbers; // les nombres pairs
std::vector<int> oddNumbers; // les nombres impairs
}
Enfin, tant qu'à parcourir l'ensemble des éléments de allNumbers afin de les afficher, pourquoi n'en profiterais tu pas, carrément, pour les placer directement dans le tableau correspondant? Cela t'éviterait d'avoir à parcourir deux fois la totalité des éléments de allNumbers
Bon, il est vrai que, avec dix éléments à peine, cela ne fait pas grosse différence... Mais, imagine avec 1 000 000 ou plus ...
Nous pourrions donc modifier le code pour qu'il ressemble à quelque chose comme
int main(){
std::vector<int> allNumbers{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
std::cou<<"je vais commencer par afficher tous les éléments\n
<<"et je ferai le tri par la meme occasion\n"
/* remarque le nom donné à l'élément que je traite */
for(auto element : allNumbers){
std::cout<<element<<" ";
if(element %2 == 0) // si c'est un nombre pair
evenNumbers.push_back(element);
else // si ce n'est pas un nombre pair, c'est
// forcément un nombre impaire
oddNumbers.push_back(element);
}
std::cout<<"\n";
std::cout<<"je vais maintenant afficher les nombres pairs :\n";
for(auto element : evenNumbers)
std::cout<<element<<" ";
std::cout<<"\n";
std::cout<<"je vais maintenant afficher les nombres impairs :\n";
for(auto element : evenNumbers)
std::cout<<element<<" ";
std::cout<<"\n";
}
Enfin, on peut essayer de respecter encore un peu plus le SRP en créant quelques fonctions "secondaires", ce qui pourrait prendre la forme de
/* une fonction qui envoie une valeur donnée vers un flux
* spécifique (et qui rajoute un espace après)
*/
std::ostream & sendToStream(std::ostream & os,int value){
return os<<value<<" ";
}
/* une fonction qui place une valeur donnée dans l'un des
* tableaux spécifique en fonction des circonstances
*/
void sort(int value, std::vector<int> & evens, std::vector<int> & odds){
if(value % 2 == 0)
evens.push_back(value);
else
odds.push_back(value);
}
/* enfin la fonction principale qui tire parti de ces deux fonctions */
int main(){
std::vector allNumbers{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
std::vector evenNumbers;
std::vector oddNumbers;
std::cou<<"je vais commencer par afficher tous les éléments\n
<<"et je ferai le tri par la meme occasion\n"
/* remarque le nom donné à l'élément que je traite */
for(auto element : allNumbers){
sendToStream(std::cout, element);
sort(element, evenNumbers, oddNumbers);
}
std::cout<<"\n";
std::cout<<"je vais maintenant afficher les nombres pairs :\n";
for(auto element : evenNumbers)
sendToStream(std::cout, element);
std::cout<<"\n";
std::cout<<"je vais maintenant afficher les nombres impairs :\n";
for(auto element : evenNumbers)
sendToStream(std::cout, element);
std::cout<<"\n";
}
(bon, j'avoue que j'ai été "un peu loin" en demandant de transmettre std::cout comme premier argument de la fonction printElement, disons que cela permet d'utiliser cette fonction pour envoyer les nombres dans ... n'importe quel flux, comme un fichier ouvert en écriture )
- Edité par koala01 10 février 2023 à 19:20:39
Ce qui se conçoit bien s'énonce clairement. Et les mots pour le dire viennent aisément.Mon nouveau livre : Coder efficacement - Bonnes pratiques et erreurs à éviter (en C++)Avant de faire ce que tu ne pourras défaire, penses à tout ce que tu ne pourras plus faire une fois que tu l'auras fait
Je suis admiratif. Je serais absolument incapable de comprendre un code simplement lu à haute voix. Quand à coder sans voir ce que j'écris, n'en parlons pas.
Je suis admiratif. Je serais absolument incapable de comprendre un code simplement lu à haute voix. Quand à coder sans voir ce que j'écris, n'en parlons pas.
Sans rien retirer au mérite qu'il y a effectivement à le faire, il faut quand même signaler qu'il y a des codes qui seront "plus faciles" à comprendre dans ces conditions, alors que d'autres seront ... beaucoup plus compliqués.
Si chaque chose (type de donnée, variable ou constante et fonction) porte un nom qui exprime clairement l'usage auquel elle est destinée et / ou sa raison d'être;
Si chaque fonction est nommée sous forme d'un verbe (ex: moveTo, findBiggerOf, isOdd, hasSomething, CanDothat, ...) et que de l'autre coté, chaque type de donnée et chaque variable est identifié par un nom, la lecture à voix haute peut en arriver à produire une phrase presque correcte, par exemple:
if (currentPosition.canMoveTo( targetPosition){
translate(allPoints, computeVectorBetween(currentPosition,targetPosition));
}
Tu n'as pas besoin de savoir comment les fonctions canMoveTo, transalte et computeVector vont réussir à fournir le résultat que l'on est en droit d'attendre de leur part. A vrai dire, en tant qu'utilisateur de ces fonctions, ce n'est même pas ton problème : si ces fonctions sont disponibles, tu t'attends -- en tant qu'utilisateur -- à ce que ces fonctions fournissent un résultat correct et cohérent à partir du moment où tu leur transmet des information valides et cohérentes.
Et c'est tout ce dont un utilisateur a besoin pour être satisfait
Par contre, il faut arriver à comprendre que tu n'est le développeur d'une fonction que le temps strictement nécessaire pour en développer l'algorithme, en écrire le code, et t'assurer qu'elle fait correctement son taf.
Une fois que cette dernière étape est passée, que tu t'es assuré que la fonction que tu viens de développer fait correctement son taf, tu te transforme irrémédiablement en utilisateur de la fonctionnalité, même si tu l'a développée à la sueur de ton propre front, avec tout ce que cela importe de connaissance minimale concernant cette fonctionnalité, à savoir:
l'usage auquel elle est destinée
le résultat que l'on est en droit d'attendre de sa part (et non la manière dont elle obtient ce résultat)
les données qu'il faudra lui transmettre pour obtenir ce résultat
les préconditions permettant d'assurer la cohérence du résultat.
Ce qui se conçoit bien s'énonce clairement. Et les mots pour le dire viennent aisément.Mon nouveau livre : Coder efficacement - Bonnes pratiques et erreurs à éviter (en C++)Avant de faire ce que tu ne pourras défaire, penses à tout ce que tu ne pourras plus faire une fois que tu l'auras fait
Séparer les pairs des impairs
× Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
× Attention, ce sujet est très ancien. Le déterrer n'est pas forcément approprié. Nous te conseillons de créer un nouveau sujet pour poser ta question.
Le Tout est souvent plus grand que la somme de ses parties.
Le Tout est souvent plus grand que la somme de ses parties.
Le Tout est souvent plus grand que la somme de ses parties.