How to create multiple objects in the same function but without overwriting each other?

Question

I'm trying to create an object in a function, but I am running into the problem that variable names have to be defined at runtime. Is there something I can do like with arrays that allows ne to dynamically create a variable in a function and preferably give it a different name from the one created when the function was called last?

***I'm working in C++

EDIT: I can't give any code because I don't have any right now. All I have right now is pseudo code.

Basically, I'm trying to create a linked list, but the addNewItem() method that I want to use would require using the same method to create different objects.

EDIT: Technically, we're not making a linklist, just more of a proof of concept to understand how they work.

EDIT: Here's the 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

If you want a linked list - call new to create each new node and then add it to the list.

Smth like this:

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

The easiest way to build a (singly) linked list is to add the new item at the front:

linklist *head = 0;

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

If it is acceptable to add items at the tail in O(N) time, then you scan the list each time to find the end.

linklist head;

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

If you must add new items at the tail of the list in O(1) time, then keep a circular list, and a pointer to the tail of the list (so that tail->next is a pointer to the head of the list). (The previous list structures could be called 'open ended'.)

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

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

Beware: the termination conditions for iterating over the entire list (e.g. to find an item in the list) vary depending on the structure used (circular versus open-ended).

Caveat: untested code!

If you aren't sure what O(1) and O(N) means, then read up on 'Big O' notation.

Answer 3

I would suggest a 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

Assuming that you need N objects of some type T:Arrays are very much present in C++. So is the STL which provides you with a host of oppertunities. You need to define how you will want to access and use these objects -- that influences the choice of your container. But can you post some code so that our answers are a little less vague (and more helpful to you)?

Answer 5

I'm not exactly sure what you want but is sounds like you could use Multiset.

Please provide more details, and I might be able to provide more help.

Answer 6

For starters I would suggest you rename your linkedlist struct to node and add a new linked list struct that holds the head, and (maybe) current / tail pointers. You should then implement methods in this class / struct that will allow you to manipulate it.

What you're missing at the moment is a method that will traverse the list (recursively getting the next pointer until you're at the end) and return a pointer to the last element. Once you have that, you can set the next pointer of that element to your newly created object.