ist es möglich...



  • eine Liste in C++ zu erzeugen,

    ohne direkt mit pointern zu arbeiten. Meine Klassen sehen wie folgt aus:

    class list{
    
      listenelement *first;
      listenelement *last;
    ...
    }
    
    class listenelement{
     int elementennummer;
     listenelement *next;
    }
    

    nun benötige ich methoden die nur einen int als rückgabewert zulassen bzw methoden in dem ein konstruktor aufgerufen werden kann. stellt sich nun die frage ob es möglich ist, so eine liste zu erzeugen. kann man denn einfach einen pointer als int und dann wieder als pointer umwandel?



  • Sorry, ich versteh dein Problem nich ganz... Was genau willst du machen? 😕



  • Nimm doch einfach die Liste aus der STL.

    #include <list>
    
    // Benutzung:
    std::list<int> liste;
    liste.push_back(1);
    liste.push_back(2);
    liste.push_back(27);
    
    // oder 
    
    liste.push_front(12);
    // ...
    
    // Wenn Du die Elemente aus der Liste bekommen möchtest...
    for(std::list<int>::iterator i = liste.begin(); i != liste.end(); ++i)
    {
        int wert = *i;
        std::cout << "Listenelement: " << wert << std::endl;
    }
    

    es gibt da noch mehr nützliche Methoden...
    siehe http://www.cppreference.com/cpplist/index.html

    Gruß Paddy



  • Edit: zu spät, zu spät ... (heute haben wir hier K*ck-langsames Netz.

    Gruß,

    Simon2.



  • matzeed77 schrieb:

    eine Liste in C++ zu erzeugen,

    ohne direkt mit pointern zu arbeiten.

    Ja. Mal abgesehen von der STL-Methode:

    Stell's dir als Tabelle vor (dass die Zeilen durcheinandergewürfelt sind, ist Absicht):

    ID  Value    ID-Next
    4   "Vier"   5
    0   "Null"   1
    1   "Eins"   2
    5   "Fünf"   6
    2   "Zwei"   3
    3   "Drei"   4
    6   "Sechs"  7
    7   "Sieben" 8
    9   "Neun"   -1
    8   "Acht"   9
    

    Das kann man z.B. über ein Array als grundlegende Datenstruktur realisieren, in etwa so:

    struct Foo {
      int id, id-next;
      std::string value;
      //usw. Ctors, Dtor...
    };
    
    Foo *x = new Foo[10];
    

    Und wenn du jetzt noch was "anhängen" möchtest (nicht vergessen, genug Speicherplatz zu reservieren), musst du die next-id der "neun" auf den neuen Wert umbiegen und dessen next-id wiederum auf -1 setzen.

    Jow 😃

    MfG

    GPC



  • mein problem ist die umgebung von woaus ich die methoden/funktionen aufrufen
    kann, da sind so sachen wie int *p; int * add(...); nicht möglich.

    ich könnte es nur in eine funktion kapseln und diese dann aufrufen

    zb void addElement(......){
    liste.push_back(1);
    }

    das problem dabei ist nur das ausserhalb die "liste" ja nicht bekannt ist und ich keinen zeiger auf die liste definieren kann. die grundstrucktur aus der die
    funktionen aufgerufen werden sollen ist ein AST der nur Attribute mit standardtypen zulässt so können also nur diese "einfachen Typen" durch den Baum
    propagiert werden aus diesem grund sind keine pointer möglich

    also ich habe zu beginn eine init() funktion in der

    void initLIST(string name){
    	cout<<"init " <<name <<endl;	
    	myLIST *neuList= new myLIST(name);	
    	return neu;	
    }
    

    mein neuer listenkopf erzeugt wird. möchte ich aber nun in "neuList" ein neues
    Listenelement einfügen benötige ich eine add() funktion diese muss aber die liste kenne und das ist mein problem
    kann mir da wer helfen



  • Irgendwie verstehe ich dein Problem nicht ganz.

    Kapsel doch die Liste in einer Klasse (zur Not auch als Singelton).

    class Liste
    {
    
    private:
       static Liste* m_pListInstance;
       std::list<int> m_List;
       Liste();
    
    public:
       void addElement(int);
       ....
       static Liste* Instance();
    };
    
    //......
    
    // Static class member attribute
    Liste* Liste::m_pListInstance( 0 );
    
    Liste* Liste::Instance()
    {
        if(m_pListInstance == 0)
        {
        	m_pListInstance= new Liste();
        }
    
        return m_pListInstance;
    }
    
    void Liste::addElement(int value)
    {
       m_List.push_back(value);
    }
    

    Wenn Du es also als Singleton implementierst, kannst Du das eine statische Objekt dieser Klasse von aussen an zig Stellen benutzen, z.B. so..

    // Test1.cpp
    #include "Liste.h"
    
    void test()
    {
       Liste::Instance()->addElement(5);
    }
    
    // test2.cpp
    #include "Liste.h"
    
    void test2()
    {
       // z.B.
       int i = Liste::Instance()->getFirstElement();
    }
    

    Die Listeninhalte, sind keine Zeiger, sondern alles rudimentäre ints.
    Du hasst dein globales Listen Singleton, welches Du über ein einfaches #include (reicht wohlbemerkt in der .cpp) einbindest. Das ist eine ziemlich lockere Bindung, im Vergleich zur Verwendung von Zeigern.

    Sollte ich jetzt voll an deinem Problem vorbei geschrieben haben, versuch mir doch nochmal dein Problem näher zu erläutern.

    Gruß Paddy



  • ja also zu meinem problem: das programm das ich verwende ist ähnlich wie BISON.
    in der Beschreibung der Grammatik der bastrakten Syntax eine Programmiersprache
    kann man zu unterstützung c/c++ funktionen aufrufen um die berechnung der Baumattribute zu erleichtern. ein teil meiner abstrakten grammatik sieht zb wie folgt aus

    program: block_list

    block_list: block block_list
    block_list: block

    block ....

    also besteht das programm aus einer liste von grundblöcken. in dieser struktur wird dann durch das anbringen von attributen ermöglicht eine auswertung der einzeilnen blockinhalte durchzuführen. nun möchte ich natürlich meine
    eigenen auswertefunktionen schreiben(in c++) und diese dann in den einzelnen
    baumknoten des AST anwenden. hierzu benötige ich meine liste aus blöcken. die
    wurzel der liste soll in program durch initlist() erzeugt werden. in dem ast-knoten block.... möchte ich nun eine funktion addblock(...) aufrufen können, die mir einen block in die durch initlist() angelegte liste hängt

    das problem besteht nun darin, der addblock(..) funktion zu sagen in welche liste sie einen neuen block hängen soll
    die syntax in der attributberechnungsprache lässt nur einfache funktionsaufrufe zu wie zb addblock(...) die parameter von addblock() können nur einfache datentypen sein zb int und auch die rückgabewerte sind nur einfache datentypen
    zb int addblock()

    was in den funktionen implementiert wird mir überlassen aslo kann ich zb in der funktion init auch ein neues objekt anlegen zb durch objekt *ob = new objekt();
    stellt sich nur die frage wie ich *ob aus der funktion bekomme ohnen * zu verwenden und diese info dann an addblock(..) weitergeben kann

    die weitergabe von attributen im AST ist halt nur über die standard datentypen wie zb int möglich


Log in to reply