Como criar vários objetos na mesma função, mas sem substituir uns aos outros?

Question

Eu estou tentando criar um objeto em uma função, mas estou correndo para o problema que nomes de variáveis ??têm que ser definidas em tempo de execução. Existe algo que eu possa fazer como com arrays que permite ne para criar dinamicamente uma variável em uma função e, preferencialmente, dar-lhe um nome diferente daquele criado quando a função foi chamado pela última vez?

*** Eu estou trabalhando em C ++

EDIT: Eu não posso dar qualquer código porque eu não tenho nenhum agora. Tudo o que eu tenho agora é pseudo-código.

Basicamente, eu estou tentando criar uma lista ligada, mas o método addNewItem () que eu quero usar exigiria usando o mesmo método para criar objetos diferentes.

EDIT: Tecnicamente, não estamos fazendo um linklist, apenas mais uma prova de conceito para entender como eles funcionam.

EDIT: Aqui está o código:

#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 você quiser uma lista ligada -. Chamada nova para criar cada novo nó e, em seguida, adicioná-lo à lista

Smth assim:

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

A maneira mais fácil de construir um (isoladamente) lista ligada é adicionar o novo item na frente:

linklist *head = 0;

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

Se for aceitável para adicionar itens na cauda em O (N) tempo, então você verificar a lista de cada vez para encontrar o fim.

linklist head;

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

Se você deve adicionar novos itens na cauda da lista em O (1) tempo, em seguida, manter uma lista circular, e um ponteiro para a cauda da lista (para que tail->next é um ponteiro para o topo da lista ). (As estruturas lista anterior poderia ser chamado de 'open terminou').

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

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

Cuidado: as condições de terminação para a iteração sobre toda a lista (por exemplo, para encontrar um item na lista) variar dependendo da estrutura utilizada (em relação circular aberto)

.

Aviso : código não testado

Se você não tem certeza o que O (1) e O (n) significa, em seguida, ler sobre a notação 'Big O'.

Answer 3

Gostaria de sugerir um vector:

#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

Assumindo que você precisa N objetos de algum tipo T: Arrays estão muito presentes em C ++. Assim é o STL, que fornece-lhe com uma série de oppertunities. Você precisa definir como você vai querer acessar e usar esses objetos - que influencia a escolha de seu recipiente. Mas você pode postar algum código para que as nossas respostas são um pouco menos vago (e mais útil para você)?

Answer 5

Eu não sei exatamente o que você quer, mas é sons como você poderia usar Multiset .

Por favor, forneça mais detalhes, e eu poderia ser capaz de fornecer mais ajuda.

Answer 6

Para começar eu sugiro que você mudar o nome do struct LinkedList ao nó e adicionar uma nova estrutura lista ligada que mantém a cabeça, e (talvez) ponteiros current / cauda. Você deve então implementar métodos dessa classe / struct que permitirá que você para manipulá-lo.

O que você está faltando no momento é um método que irá percorrer a lista (de forma recursiva recebendo o ponteiro próxima até que você esteja no final) e retornar um ponteiro para o último elemento. Uma vez que você tem isso, você pode definir o próximo ponteiro desse elemento ao seu objeto recém-criado.