Hoe om veelvuldige voorwerpe in dieselfde funksie te skep, maar sonder om mekaar te oorskryf?

Question

Ek probeer om 'n objek in 'n funksie te skep, maar ek kry die probleem dat veranderlike name tydens looptyd gedefinieer moet word.Is daar iets wat ek kan doen soos met skikkings wat ne toelaat om 'n veranderlike in 'n funksie dinamies te skep en dit verkieslik 'n ander naam te gee as die een wat geskep is toe die funksie laas genoem is?

***Ek werk in C++

EDIT:Ek kan nie enige kode gee nie, want ek het nie op die oomblik enige nie.Al wat ek nou het, is pseudo-kode.

Basies probeer ek om 'n gekoppelde lys te skep, maar die addNewItem() metode wat ek wil gebruik, sal vereis dat dieselfde metode gebruik word om verskillende voorwerpe te skep.

EDIT:Tegnies maak ons ​​nie 'n skakellys nie, net meer 'n bewys van konsep om te verstaan ​​hoe dit werk.

EDIT:Hier is die kode:

#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

As jy 'n gekoppelde lys wil hê - bel nuwe om elke nuwe nodus te skep en voeg dit dan by die lys.

Smth soos hierdie:

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

Die maklikste manier om 'n (eenvoudig) gekoppelde lys te bou, is om die nuwe item aan die voorkant by te voeg:

linklist *head = 0;

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

As dit aanvaarbaar is om items by die stert in O(N) tyd by te voeg, dan skandeer jy die lys elke keer om die einde te vind.

linklist head;

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

As jy nuwe items by die stert van die lys moet byvoeg in O(1) tyd, hou dan 'n omsendbrief lys, en 'n wyser na die stert van die lys (sodat tail->next is 'n wyser na die kop van die lys).(Die vorige lysstrukture kan 'oop einde' genoem word.)

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

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

Pasop:die beëindigingsvoorwaardes vir iterasie oor die hele lys (bv.om 'n item in die lys te vind) wissel na gelang van die struktuur wat gebruik word (sirkelvormig teenoor oop einde).

Waarskuwing:ongetoetste kode!

As jy nie seker is wat O(1) en O(N) beteken nie, lees dan op 'Groot O'-notasie.

Answer 3

Ek sou 'n vektor voorstel:

#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

Aanvaar dat jy nodig het N voorwerpe van een of ander soort T: Skikkings is baie teenwoordig in C++.So ook die STL wat jou 'n magdom geleenthede bied.Jy moet definieer hoe jy toegang tot hierdie voorwerpe wil verkry en gebruik -- dit beïnvloed die keuse van jou houer.Maar kan jy 'n kode plaas sodat ons antwoorde 'n bietjie minder vaag is (en nuttiger vir jou)?

Answer 5

Ek is nie presies seker wat jy wil hê nie, maar dit klink of jy kan gebruik Multiset.

Verskaf asseblief meer besonderhede, en ek kan dalk meer hulp verskaf.

Answer 6

Om mee te begin, sal ek voorstel dat jy jou gekoppelde lys-struktuur na node hernoem en 'n nuwe gekoppelde lysstruktuur byvoeg wat die kop hou, en (miskien) huidige / stertwysers.Jy moet dan metodes in hierdie klas / struktuur implementeer wat jou sal toelaat om dit te manipuleer.

Wat jy op die oomblik mis, is 'n metode wat die lys sal deurkruis (rekursief die volgende wyser kry totdat jy aan die einde is) en 'n wyser na die laaste element terugstuur.Sodra jy dit het, kan jy die volgende wyser van daardie element op jou nuutgeskepte voorwerp stel.