Utiliser les paramètres de la fonction main

Bonjour,

Je fais face à un petit problème : j'utilise

Code:

---

int main(int argc, char *argv[])

---

et j'aimerais faire un traitement sur tous les paramètres (de nombre inconnu) passés à la fonction main.
Pour cela je créé un tableau :

Code:

---

double tableauDeDouble[argc-1]; //erreur argc ne peut pas être défini comme une constante

---

et ensuite à l'aide d'une boucle for simple je parcours argv et je calcule les doubles correspondant que je place dans tableauDeDouble.

Du coup, j'aimerais savoir comment utiliser argc pour créer mon tableau (ou s'il existe une autre solution).

Chapitre 0 : les tableaux ce sont des std::vector.

https://cpp.developpez.com/faq/cpp/?...vec-std-vector

Ça a effectivement l'air de marcher avec les vectors...

Je me demandais quand même s'il existe un moyen de faire sans cette bibliothèque ?

Cette bibliothèque s'appelle le standard. :calim2:
Après vu les infos inexistantes initiales, oui il y a sûrement plein de façons de faire imaginables, à commencer par ne pas stocker les données ailleurs que dans argv qui les contient déjà.

Oui j'ai en effet trouvé une autre solution sur un autre forum qui consiste à utiliser :

Code:

---

double* mesDoubles = new double[argc - 1];

---

Par contre je suis assez sceptique à l'idée d'utiliser un char** pour stocker des doubles...

Cette façon de faire est de loin la pire.

Un petit truc que j'avais pas précisé (mais je pensais que ma question le laissait deviner facilement), c'est que je suis débutant dans ce langage.

Du coup, avant de me lancer dans des objets<type> etc... j'aimerais bien commencer par le début. C'est pour cela que j'ai demandé s'il existait un moyen sans avoir à importer quoi que ce soit (puisqu'apparemment il ne s'agit pas de bibliothèque mais probablement de classes je dirai bien que je sois toujours pas très sûr)...

Tu dis qu'il existe plein de façon de faire sans, mais tu ne me dis pas comment faire (ou ne m'indique pas une seule piste). De plus, lorsque je te présente une solution (peut-être mauvaise j'en sais rien mais au moins ça marche) tu me dis de chercher un autre moyen. Moi je suis pas contre trouver une autre solution, mais j'aimerais comprendre pourquoi il s'agit de la pire solution et j'aimerais obtenir au moins un indice sur la meilleur méthode (et pourquoi c'est la meilleur) à employer, parce que sinon je risque de mettre du temps avant de trouver cette solution.

La meilleure méthode est std::vector. Ce que doit utiliser un débutant est std::vector. Ce que va utiliser une personne expérimentée est std::vector. std::vector est dans le standard de C++, il n'y a aucune raison d'aller chercher autre chose, surtout pour un débutant. Si un cours ne présente pas std::vector dans les premiers chapitres, il faut s'en débarrasser immédiatement, c'est un très mauvais cours.

Citation:

---

Du coup, avant de me lancer dans des objets<type> etc... j'aimerais bien commencer par le début.

---

std::cout est un objet, et pourtant c'est la première chose qu'on manipule. std::string aussi.

Par contre, new n'est clairement pas à la portée d'un débutant, cela implique d'avoir une correspondance avec delete, de faire la différence entre new/new[] et delete/delete[] et de comprendre les exceptions et le RAII. Personne n'utilise new directement, on dispose de mécanismes bien meilleurs pour ça, std::vector en fait partie.

Citation:

---

Tu dis qu'il existe plein de façon de faire sans, mais tu ne me dis pas comment faire

---

Tu ne donnes pas non plus la problématique, mais une solution à une problèmatique. Avoir besoin d'un tableau de double est une des solutions possibles, cela n'est peut-être pas nécessaire.

std::vector est dans le standard. L'utiliser est aussi évident que std::cout, std::string, int ou double.
J'ai donné un lien vers une FAQ qui montre comment utiliser std::vector.
Tu peux aussi utiliser ton ordinateur pour chercher sur un moteur de recherche et trouver la doc qui présente toute son interface et des millions d'exemples d'utilisation si ça suffit pas.
Nous ne sommes pas ici pour faire le travail d'un autre, débutant ou pas. Être débutant n'est pas une excuse pour ne pas faire de recherches, ne pas lire les réponses apportées ou les liens fournis.
Tu veux stocker des trucs ? Utilise std::vector comme indiqué dans la toute première réponse.
Tu préfères utiliser un tableau dynamique trouvé sur un autre forum ou que sais-je ? Fais-toi plaisir, mais ta source est médiocre et cette solution est mauvaise.
Combien de fois doit-on écrire d'utiliser std::vector pour que ça soit compris ? Combien de liens doit-on montrer pour qu'ils soient ouverts et lus ?
Quant à savoir que faire de ces données et comment les traiter, faudrait déjà que tu dises ce que tu comptes en faire vraiment..

Citation:

---

Envoyé par thomas18F

j'aimerais comprendre pourquoi il s'agit de la pire solution et j'aimerais obtenir au moins un indice sur la meilleur méthode (et pourquoi c'est la meilleur) à employer, parce que sinon je risque de mettre du temps avant de trouver cette solution.

---

Tu sais que le C++ est une surcouche du C, et donc les solutions en C fonctionnent en C++, mais les solutions en C++ ne fonctionnent pas en C.

:mrgreen: et l'autre truc, c'est que c'est débile ce que tu demandes :wow: si tu ne veux pas utiliser la bibliothèque standard STL, bien saches que les fonctions comme malloc, printf, fopen proviennent de la bibliothèque standard C - en pur C et pur C++ tu ne fais rien :ptdr:

Solution 1 en C : le tableau fixe - ce que tu as essayé double array[15];. Le truc à savoir :mrgreen: c'est que la taille de ce tableau doit être connue à la compilation.
1 contournement possible :mrgreen:, c'est de fixer une taille "la plus large possible pour contenir les données". Pour ton cas, par exemple, double array[100];.

Avec la norme C99 :zoubi:, tu as la possibilité des VLA (variable-length array), mais déprécié depuis la norme C11.

Solution 1-bis depuis le C++11, donnée par @jo_link_noir : le tableau fixe, std::array.

Solution 2 en C et C++ : faire une allocation dynamique. Tu prends 1 pointeur double* array;. Et 1 fois que tu connais la taille, tu alloues le tableau (en C) array = malloc(size * sizeof(double); (en C++) array = new double[size] (<- attention ce n'est pas l'opérateur new mais new[])
Et qui dit allocation dynamique, dit désallocation avec (en C) free(array); (en C++) delete[] array; ... et donc la difficulté :mrgreen: est de savoir quand la faire et de ne pas la faire trop tôt (comme lorsque une exception est lancée par exemple).

La différence :zoubi:, c'est qu'en C, tu peux changer la taille de ton tableau avec la fonction realloc.

Solution 3 en C++ : std::vector, tableau dynamique qui gère les questions d'allocations et de désallocations. Tu peux réserver une taille au début si tu le veux, et ensuite tu ajoutes ou supprimes tes donnés sans te prendre la tête.
1 différence avec les tableaux fixes (solution 1 et solution 2) pour parcourir un vector tu peux le faire classiquement avec 1 boucle, mais également avec des itérateurs ... et depuis la norme C++11 avec un "range-based for loop" :zoubi:

Édit : Mon V.D.D. (mon voisin du dessous) @jo_link_noir me dit que les itérateurs existent en C. Oui mais il faut coder la classe. En C++ avec les classes STL, tu les as par défaut.

Solutions autres 1 en C et C++ : Tu as aussi des solutions avec des structures de données non contiguës en mémoire. Tu peux coder 1 liste chaînée (soit 1 maillon contient 1 valeur mais question mémoire ce n'est pas terrible soit 1 maillon contient X valeurs, X fixe). Donc, c'est le même principe que la solution 2 avec l'allocation dynamique.

Solutions autres 2 en C++ : Tu as aussi des solutions avec des structures de données non contiguës en mémoire. std::deque, std::list, ...


Voila, et on attend tous ton prochain sujet :mrgreen: lorsque que tu comprendras que les données de argv sont de type chaînes de caractères "3586.14145" (parce que les arguments sont passés en ligne de commande) et non pas flottant 3586.14145.
Et en plus, tu vas découvrir les joies des conversions flottantes avec leur précision souvent pourrie :whistle:

Je ne vois pas l’intérêt de parler du C et encore moins de présenter des solutions basées dessus.

Et sinon, pour les tableaux à taille fixe -> std::array

Citation:

---

1 différence avec les tableaux fixes (solution 1 et solution 2) pour parcourir un vector tu peux le faire classiquement avec 1 boucle, mais également avec des itérateurs ... et depuis la norme C++11 avec un "range-based for loop"

---

Les boucles et itérateurs sont aussi possibles avec les tableaux C.

Merci pour ta grande aide foetus :mrgreen:

Et pas d'inquiétude au sujet du type d'argv, j'ai bien compris que c'était des char*.


Sinon Bousk quand je disais : "Ça a effectivement l'air de marcher avec les vectors...", c'était pour exprimer que j'avais réussit à utiliser les vectors grâce à la doc que tu m'as donné. Du coup, je suis pas certain de comprendre ce que tu entends par :"Être débutant n'est pas une excuse pour ne pas faire de recherches, ne pas lire les réponses apportées ou les liens fournis."

Et puisque tu sembles insister sur le but de mon programme, le but est de passer des chemins de fichier en paramètre au main pour en faire une analyse syntaxique et lexicale, puis de stocker le résultat sous forme de double dans un tableau de double.

Pourquoi mettre le résultat dans un tableau, pour en faire quoi ?

Le but est d'attribuer un "rôle" à chaque fichier... Pour la suite j'ai peur que ce soit un peu hors-sujet vu que ce n'est même plus du c++.