Comment créer plusieurs objets dans la même fonction mais sans se remplacer?

Question

J'essaie de créer un objet dans une fonction, mais le problème, c'est que les noms de variables doivent être définis au moment de l'exécution. Est-ce que je peux faire quelque chose comme avec les tableaux qui permettent de ne pas créer dynamiquement une variable dans une fonction et lui donner de préférence un nom différent de celui créé lors du dernier appel de la fonction?

*** Je travaille en C ++

EDIT: Je ne peux pas donner de code parce que je n'en ai pas pour le moment. Tout ce que j’ai pour l’instant, c’est du pseudo-code.

En gros, j'essaie de créer une liste chaînée, mais la méthode addNewItem () que je veux utiliser nécessiterait l'utilisation de la même méthode pour créer différents objets.

EDIT: Techniquement, nous ne faisons pas une liste de liens, mais plutôt une preuve de concept pour comprendre comment ils fonctionnent.

EDIT: Voici le code:

#include "linklist.h"
#include <iostream>
using namespace std;

struct linklist
{
    Student * obj;
    linklist * next;
};

linklist * head;

int main()
{

}
void addStudent(char * newsdnt)
{
    if(!head){
            linklist * a = new linklist;
            a->obj = new Student(newsdnt);
            a->next = 0;
            head = a;
            return;
    }else{
            linklist * a = new linklist;
            a->obj = new Student(newsdnt);
            a->next = 0;
            if(!head->next){
                    head->next = a;  // Can only have one or two items in list
            }
    }

}

Answer 1

Si vous souhaitez une liste chaînée, appelez new pour créer chaque nouveau nœud, puis ajoutez-le à la liste.

Smth comme ceci:

void addStudent(char * newsdnt)
{
    linklist* a = new linklist;
    a.obj = new Student(newsdnt);
    a.next = 0;

    if( head == 0 ) {
        head = a;
    } else {
        linklist* whereToAdd = head;
        while( whereToAdd.next != 0 ) {
            whereToAdd = whereToAdd.next;
        }
        whereToAdd.next = a;
    }
}

Answer 2

Le moyen le plus simple de créer une liste chaînée (seule) consiste à ajouter le nouvel élément à l'avant:

linklist *head = 0;

...
a->next = head;
head = a;
...

S'il est acceptable d’ajouter des éléments à la fin du temps réglementaire (O), vous parcourez chaque fois la liste pour rechercher la fin.

linklist head;

...
a->next = 0;
item = &head;
while (item->next != 0)
    item = item->next;
item->next = a;
...

Si vous devez ajouter de nouveaux éléments à la fin de la liste dans O (1) time, conservez une liste circulaire et un pointeur sur la fin de la liste (pour que tail- > next est un pointeur sur l'en-tête de la liste). (Les structures de liste précédentes pourraient être appelées 'ouvertes'.)

linklist  root = { 0, &root };
linklist *tail = &root;

...
a->next = tail;
tail->next = a;
...

Attention: les conditions de terminaison pour parcourir la liste entière (par exemple, pour trouver un élément dans la liste) varient en fonction de la structure utilisée (circulaire ou ouverte).

Avertissement : code non testé!

Si vous ne savez pas ce que signifie O (1) et O (N), lisez la notation "Big O".

Answer 3

Je suggérerais un vecteur:

#include <vector>
using namespace std;
void foo()
{
    vector<int> v;
    v.push_back(1);
    v.push_back(2);
    v.push_back(3);
    cout << v[0] + v[1] << endl;
}

Answer 4

En supposant que vous ayez besoin d'objets N de type T : Les tableaux sont très présents en C ++. Il en va de même pour la STL, qui vous offre une foule d’options. Vous devez définir comment vous souhaitez accéder à ces objets et les utiliser, ce qui influence le choix de votre conteneur. Mais pouvez-vous poster du code pour que nos réponses soient un peu moins vagues (et plus utiles pour vous)?

Answer 5

Je ne suis pas tout à fait sûr de ce que vous voulez, mais il semble que vous puissiez utiliser Multiset .

Veuillez fournir plus de détails. Je pourrais peut-être vous aider davantage.

Answer 6

Pour commencer, je vous suggérerais de renommer votre structure de liste liée en noeud et d'ajouter une nouvelle structure de liste liée contenant la tête et (peut-être) les pointeurs actuels / finaux. Vous devez ensuite implémenter des méthodes dans cette classe / structure pour pouvoir les manipuler.

Ce qui vous manque pour le moment, c’est une méthode qui parcourt la liste (obtenant récursivement le pointeur suivant jusqu’à la fin) et renvoie un pointeur sur le dernier élément. Une fois que vous avez cela, vous pouvez définir le prochain pointeur de cet élément sur votre nouvel objet créé.