Come creare più oggetti nella stessa funzione ma senza sovrascriverli?

Question

Sto cercando di creare un oggetto in una funzione, ma sto riscontrando il problema che i nomi delle variabili devono essere definiti in fase di esecuzione. C'è qualcosa che posso fare con gli array che consente a ne di creare dinamicamente una variabile in una funzione e preferibilmente di darle un nome diverso da quello creato quando la funzione è stata chiamata per ultima?

*** Sto lavorando in C ++

EDIT: Non posso dare alcun codice perché non ne ho al momento. Tutto quello che ho ora è lo pseudo codice.

Fondamentalmente, sto cercando di creare un elenco collegato, ma il metodo addNewItem () che voglio usare richiederebbe l'utilizzo dello stesso metodo per creare oggetti diversi.

EDIT: Tecnicamente, non stiamo creando un elenco di collegamenti, ma solo una prova del concetto per capire come funzionano.

EDIT: ecco il codice:

#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

Se si desidera un elenco collegato, chiamare nuovo per creare ogni nuovo nodo e quindi aggiungerlo all'elenco.

Smth in questo modo:

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

Il modo più semplice per creare un elenco (singolarmente) collegato è aggiungere il nuovo elemento in primo piano:

linklist *head = 0;

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

Se è accettabile aggiungere elementi in coda in O (N), allora si scansiona l'elenco ogni volta per trovare la fine.

linklist head;

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

Se devi aggiungere nuovi elementi in coda all'elenco nel tempo O (1), allora mantieni un elenco circolare e un puntatore alla coda dell'elenco (in modo che tail- > next è un puntatore all'inizio della lista). (Le strutture dell'elenco precedente potrebbero essere chiamate "aperte").

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

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

Attenzione: le condizioni di terminazione per iterare sull'intero elenco (ad es. per trovare un elemento nell'elenco) variano in base alla struttura utilizzata (circolare contro aperto).

Avvertenza : codice non testato!

Se non sei sicuro di cosa significhino O (1) e O (N), leggi sulla notazione 'Big O'.

Answer 3

Vorrei suggerire un vettore:

#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

Supponendo che siano necessari oggetti N di un certo tipo T : le matrici sono molto presenti in C ++. Lo stesso vale per l'STL che offre una serie di opportunità. Devi definire come accedere e utilizzare questi oggetti, il che influenza la scelta del tuo contenitore. Ma puoi pubblicare del codice in modo che le nostre risposte siano un po 'meno vaghe (e più utili per te)?

Answer 5

Non sono esattamente sicuro di cosa tu voglia, ma sembra che potresti usare Multiset .

Fornisci ulteriori dettagli e potrei essere in grado di fornire ulteriore assistenza.

Answer 6

Per i principianti, suggerirei di rinominare la struttura della lista collegata al nodo e aggiungere una nuova struttura della lista collegata che contiene la testa e (forse) i puntatori corrente / coda. Dovresti quindi implementare metodi in questa classe / struttura che ti consentano di manipolarlo.

Quello che ti manca al momento è un metodo che attraverserà l'elenco (ottenendo ricorsivamente il puntatore successivo fino alla fine) e restituirà un puntatore all'ultimo elemento. Una volta che lo hai, puoi impostare il puntatore successivo di quell'elemento sul tuo oggetto appena creato.