¿Cómo crear múltiples objetos en la misma función pero sin sobrescribirse unos a otros?

Question

Estoy tratando de crear un objeto en una función, pero me encuentro con el problema de que los nombres de las variables deben definirse en tiempo de ejecución. ¿Hay algo que pueda hacer con las matrices que le permita a ne crear dinámicamente una variable en una función y, de preferencia, darle un nombre diferente al creado cuando se llamó a la función por última vez?

*** Estoy trabajando en C ++

EDITAR: No puedo dar ningún código porque no tengo ninguno en este momento. Todo lo que tengo ahora es pseudo código.

Básicamente, estoy tratando de crear una lista vinculada, pero el método addNewItem () que deseo usar requeriría usar el mismo método para crear diferentes objetos.

EDITAR: Técnicamente, no estamos haciendo una lista de enlaces, solo una prueba de concepto para entender cómo funcionan.

EDITAR: Aquí está el 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

Si desea una lista vinculada, llame a new para crear cada nuevo nodo y luego agréguelo a la lista.

Algo así:

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

La forma más fácil de crear una lista enlazada (individualmente) es agregar el nuevo elemento en la parte frontal:

linklist *head = 0;

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

Si es aceptable agregar elementos en la cola en O (N), entonces escanea la lista cada vez para encontrar el final.

linklist head;

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

Si debe agregar nuevos elementos al final de la lista en O (1), mantenga una lista circular y un puntero a la cola de la lista (de modo que tail- > next es un puntero a la cabeza de la lista). (Las estructuras de lista anteriores podrían denominarse 'final abierto').

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

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

Cuidado: las condiciones de terminación para la iteración en toda la lista (por ejemplo, para encontrar un elemento en la lista) varían según la estructura utilizada (circular versus abierta).

Advertencia : ¡código no probado!

Si no está seguro de lo que significan O (1) y O (N), lea la notación 'Big O'.

Answer 3

Sugeriría un 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

Suponiendo que necesita N objetos de algún tipo T : Las matrices están muy presentes en C ++. Así es el STL que le proporciona una gran cantidad de oportunidades. Debe definir cómo desea acceder y usar estos objetos, que influyen en la elección de su contenedor. Pero, ¿puedes publicar algún código para que nuestras respuestas sean un poco menos vagas (y más útiles para ti)?

Answer 5

No estoy exactamente seguro de lo que quieres, pero suena como si pudieras usar Multiset .

Por favor, proporcione más detalles, y es posible que pueda proporcionarle más ayuda.

Answer 6

Para empezar, le sugeriría que cambie el nombre de su estructura de lista vinculada a nodo y agregue una nueva estructura de lista vinculada que contenga la cabecera, y (tal vez) los punteros actuales / de cola. Luego deberías implementar métodos en esta clase / estructura que te permitan manipularlo.

Lo que te falta en este momento es un método que recorrerá la lista (obtener el siguiente puntero de forma recursiva hasta que estés al final) y devolverá un puntero al último elemento. Una vez que tenga eso, puede establecer el siguiente puntero de ese elemento a su objeto recién creado.