J'aimerais savoir si il est possible de créer un programme en C++ où au moins de manière théorique, qui déclare des variables lui-même sans que le développeur ai écrit au préalable les variables à créer. Par exemple, une boucle qui à chaque fois déclare une nouvelle variable.
Le problème, c'est que quand on déclare une variable, que je sache, on lui attribue un nom, et si on veut faire ce type de programme, je ne vois pas comment faire en sorte de déclarer une variable qui portera à chaque fois un nom différent puisque en pratique, tout ce qui est inscrit entre le type de la variable est son initialisation est défini comme le nom de la variable, donc on ne peut même pas récupérer des chaines de caractère stockés dans une liste par exemple.
J'aimerais bien comprendre comment faire ça, quelqu'un en a une idée ?
Il faut comprendre que seul le compilateur a besoin de nommer des variables.
Et encore, si le compilateur/optimiseur "voit" que vous ne foutez rien avec ces variables, il est en droit de ne même pas générer du code correspondant au stockage des valeurs "stockées dans la variable".
La récupération de valeurs de variables par leur 'identifiants/noms" n'est souvent possible que dans des langages interprétés, ce que n'est pas le C++.
>Par exemple, une boucle qui à chaque fois déclare une nouvelle variable.
do
{
auto pobj = new Object();
}while(true);
Cela créera autant d'objet "Object" qu'il faudra pour remplir le tas, (si l'optimiseur ne supprime pas tout le code).
Avec le std::vector de @Fvirtman :
std::vector<int> t;
do
{
t.push_back(t.size());
}while(true);
Je recherche un CDI/CDD/mission freelance comme Architecte Logiciel/ Expert Technique sur technologies Microsoft.
Je sais ce qu'est un tableau dynamique et comment l'utiliser, mais ma question n'était pas très claire : je veux plus précisément créer des variables globales.
@bacelar, dans ton premier code, la boucle va créer un nouvel objet à chaque fois, mais comme le nom ne change pas, impossible de récupérer chacun des objets !
Ce que je cherche à faire du coup, c'est pouvoir faire ce premier code mais pouvoir changer le nom de la variable à chaque fois que la boucle recommence, et donc de pouvoir accéder à toute ces variables.
> Ce que je cherche à faire du coup, c'est pouvoir faire ce premier code mais pouvoir changer le nom de la variable à chaque fois que la boucle recommence,
Est-ce que tu peux donner un exemple simple - même avec une syntaxe imaginaire - d'utilisation de telles variables ?
Souvent, quand on se pose ce genre de question, c'est dans le vide, et ça ne correspond pas du tout à un besoin (en plus d'être impossible à réaliser).
> et donc de pouvoir accéder à toute ces variables.
Question pratique, pour accéder à des variables, il faut pouvoir les désigner. Comment tu vas faire, si tu n'en connais pas le nom ?
En fait, ce qui fait que je ne peux pas créer ces variables dans un tableau dynamique, c'est que j'ai besoin de pouvoir créer une infinité de variables.
Je crois que ce n'est pas possible avec un vector, étant donné que la méthode size() d'un vector renvoie un "long long", et ça a donc une limite.
En fait, ce qui fait que je ne peux pas créer ces variables dans un tableau dynamique, c'est que j'ai besoin de pouvoir créer une infinité de variables.
Je crois que ce n'est pas possible avec un vector, étant donné que la méthode size() d'un vector renvoie un "long long", et ça a donc une limite.
La méthode size() renvoie un long long (ou un size_t), sur nos processeurs 64 bits, ça a une limite de 2^64 octets -> c'est un nombre à 20 chiffres, qui correspondrait a des milliers de milliards de giga octets. As tu cela de disponible sur ta machine ?
Tu devrais plutôt nous donner un exemple concret de ce que tu veux faire. mais crois moi, std::vector t'alloueras tout ce que tu voudras... (ta machine plantera avant que size() atteigne sa limite...)
La valeur maximale que peut prendre un long long est bien le cadet de tes soucis ...
long long est codé sur 64bits minimum, sa valeur maximale est 2^63 - 1 et même 2^64 - 1 = 18 446 744 073 709 551 615 si tu prends un unsigned long long. Pourquoi aurais tu besoin d'autant de variables ?
Ton ordinateur va fumer noir (ou ton programme va juste planter par manque de mémoire sur le PC) bien avant que tu ne remplisses ton vector d'autant d'élément
En fait, ce qui fait que je ne peux pas créer ces variables dans un tableau dynamique, c'est que j'ai besoin de pouvoir créer une infinité de variables.
Tu as besoin de variables de types différents, ou juste de valeurs différentes ? Dans le premier cas, tu vas te faire des noeuds au cerveau (en admettant que ce soit possible), dans le second cas tu as juste besoin d'un tableau dynamique.
Si vous ne trouvez plus rien, cherchez autre chose.
Comme ça déjà été demandé, pourquoi as-tu besoin d'autant de variables? Apprends le Python, il va te générer le code C++ approprié. nombre = 0 while True: print(f" variable{nombre} = valeur{nombre};") nombre += 1
Le Tout est souvent plus grand que la somme de ses parties.
On peut créer des variables et bien plus encore grâce à un metaprogramme, c’est à dire un programme qui génère un programme. Les templates sont une forme limitée de metaprogramme
Un std::vector<char> ferait l'affaire si tu veux coder toi-même les "pseudo"-opérations. Tu fais les choses à l'envers, le chiffre le moins significatif en position 0. Tu peux ajouter autant de chiffres que tu veux.
Le Tout est souvent plus grand que la somme de ses parties.
> Les chiffres sont en général stockés dans une chaîne de caractère.
Nope. On ne stocke pas des chiffres (*) mais des nombres et de préférence avec plein de bits dedans. Genre un std::vector<std::uintmax_t> en interne (quoique que gmp a l'air d'employer juste du `long`...) -> but minimiser les opérations que le proc fera très bien tout seul comme propager des retenues. Si les digits ont 32 à 64 bits au lieu de 10 maigres valeurs possibles, autant dire qu'il y aura moins de manipulations à faire à la main
(*) à part les hurluberlus qui ont pondu le BCD (quelle idée saugrenue!)
PS: il y a sur le forum un vieil exo/défi d’implémenter une classe de nombre entier à précision arbitraire qui date du sdz.
Merci pour toute vos réponses ! Malheureusement, je ne souhaite pas juste utiliser cela, mais surtout comment ça fonctionne, comment des gens ont ils pu créer cette possibilité de pouvoir étendre un nombre jusqu'à l'infini alors que les langages de programmations ont toujours une limite ?
Merci pour toute vos réponses ! Malheureusement, je ne souhaite pas juste utiliser cela, mais surtout comment ça fonctionne, comment des gens ont ils pu créer cette possibilité de pouvoir étendre un nombre jusqu'à l'infini alors que les langages de programmations ont toujours une limite ?
Alors dans les faits, ça ne va pas jusqu'à l'infini. ça va jusqu'à ... ce qu'il n'y ait plus de mémoire, c'est tout.
La méthode la plus simple (mais pas la plus optimale), c'est que tu te crées une std::string, et dedans tu mets tes chiffres 0,1,2,3 etc... comme on fait à l'école. Si on veut ajouter un chiffre, bah on agrandit la string (il y a la méthode push_back aussi), et ensuite tu recodes les opérations...
Tu pourras obtenir des nombres avec des millions, voir des milliards de chiffres si tu veux. Mais jamais l'infini.
Merci pour toute vos réponses ! Malheureusement, je ne souhaite pas juste utiliser cela, mais surtout comment ça fonctionne, comment des gens ont ils pu créer cette possibilité de pouvoir étendre un nombre jusqu'à l'infini alors que les langages de programmations ont toujours une limite ?
Merci pour toute vos réponses ! Malheureusement, je ne souhaite pas juste utiliser cela, mais surtout comment ça fonctionne, comment des gens ont ils pu créer cette possibilité de pouvoir étendre un nombre jusqu'à l'infini alors que les langages de programmations ont toujours une limite ?
Ça marche avec l'allocationdynamique. L'espace accordé à une variable "bignum" pour y stocker un nombre arbitrairement grand n'est pas fixé à la compilation (*), et change en cours d'exécution. Quand l'espace est trop petit pour y mettre un nombre trop grand, on remplace par un espace plus grand, de taille suffisante
(*) comme il l'est pour des int, des long etc (tous les types de base de C) dont la taille est immuable.
Alors dans les faits, ça ne va pas jusqu'à l'infini. ça va jusqu'à ... ce qu'il n'y ait plus de mémoire, c'est tout.
La méthode la plus simple (mais pas la plus optimale), c'est que tu te crées une std::string, et dedans tu mets tes chiffres 0,1,2,3 etc... comme on fait à l'école. Si on veut ajouter un chiffre, bah on agrandit la string (il y a la méthode push_back aussi), et ensuite tu recodes les opérations...
Tu pourras obtenir des nombres avec des millions, voir des milliards de chiffres si tu veux. Mais jamais l'infini.
Merci ! Je suppose donc qu'un string n'a pas d'autre limite que la mémoire de l'ordinateur ?
Ça pourrait être plus grand, puisqu'on utilise en realité une mémoire virtuelle qui étend la mémoire physique par de l'espace réservé sur le disque (espace d'echange).
Mais en pratique, que faire d'une chaîne de centaines de giga-octets ?
Mais en pratique, que faire d'une chaîne de centaines de giga-octets ?
- Edité par michelbillaud il y a environ 1 heure
Stocker des nombre des millier de fois plus grand que la limite d'un unsigned long long par exemple ? Enfin si j'ai bien compris il me semble que c'est possible.
Il suffit d'une dizaine de bits en plus pour disposer de 1000 fois plus d'entiers. Alors rien qu'avec un std::array<std::uint64_t, 2>, on peut modéliser des nombres à 128 bits, c'est excessivement plus que x1000.
>Stocker des nombre des millier de fois plus grand que la limite d'un unsigned long long par exemple ?
Stocker un nombre des milliards de fois plus grand que la limite d'un unsigned long long avec le bon formalisme, cela peut prendre que quelques octets en mémoire.
Comme @Yixraie semble assez novice et pour qu'il n'interprète pas de travers "toute la mémoire", il faut savoir que les ordinateurs "modernes" (depuis las années 50, je crois) utilisent "l'architecture" Van Neuman, qui fait que le code et les données partagent l'espace d'adressage d'un processus.
La taille de l'espace d'adressage d'un processus est fonction de l'OS et de divers options d'exécution et/ou de compilations. La répartition entre le code et LES espaces mémoires pour les données sont aussi fonction de l'OS et des modèles mémoire des processus.
Mais rien n'empêche un développeur d'implémenter des niveaux d'indirection d'accès aux données (utilisation d’extensions hardware, de mise en mémoire de masse, etc...) même si ces mécanismes ne sont pas implémentés directement dans le langage de programmation.
Le langage de programmation est un outil, pas un carcan.
Et en C++, le développeur a la possibilité de créer ses propres types, via les classes et donc d'en créer "parfaitement" adaptées à ces besoins.
Mais avec les autres langages, c'est toujours possible, mais c'est pas forcement aussi simple à implémenter.
Après, que des calculs sur ce type de données soient "performants", c'est pas gagner, c'est une question de compromis et d'usage.
Je recherche un CDI/CDD/mission freelance comme Architecte Logiciel/ Expert Technique sur technologies Microsoft.
Recueil de code C et C++ http://fvirtman.free.fr/recueil/index.html
Recueil de code C et C++ http://fvirtman.free.fr/recueil/index.html
Si vous ne trouvez plus rien, cherchez autre chose.
Le Tout est souvent plus grand que la somme de ses parties.
Le Tout est souvent plus grand que la somme de ses parties.
Recueil de code C et C++ http://fvirtman.free.fr/recueil/index.html