Ich arbeite momentan an einem evolutionären Algorithmus. Dabei unterscheidet man zwischen Individuen und Populationen, wobei X Individuen zu einer Population gehören. Um die Entwicklung meiner Individuen/Populationen verfolgen zu können, habe ich Datenpakete angelegt und diese in einer Hierarchie strukturiert. Die Datenpakete sind bei mir Strukturen(struct), da ich noch mit Ansi C arbeite. Konkret sieht der Aufbau bei mir folgendermaßen aus:

//Struktur zur Aufnahme von Residueninfos---------------------------------------
        typedef struct CurRes{
            int pol;
            int X;
            int Y;
        }CuRe;

        typedef struct ResDatCol{
            CuRe *ResDat;
            int NumPos;
            int NumNeg;
            int NumRes;
        }ReDa;

//Struktur zur Aufnahme der Population------------------------------------------
        typedef struct indstr{
            double *Ampl;
            double *Phse;
            double fitness;
            ReDa *Res;
        }IndTempl;

        typedef struct popstr{
            int iIFTA;  //index IFTA
            int iGen;   //index Generation
            IndTempl *Ind;
        }PopTempl;

        PopTempl Popula1;

//Initialisierung der Populationsstruktur
    Popula1.iIFTA=0;
    Popula1.iGen=0;
    Popula1.Ind=new IndTempl[psz];
    for(int i=0;i<psz;i++)
    {
        Popula1.Ind[i].Ampl=new double[sizePIC];
        Popula1.Ind[i].Phse=new double[sizePIC];
        Popula1.Ind[i].Res=new ReDa;
        Popula1.Ind[i].fitness=0;
        //Initialisierung der ResiduenStruktur
            (Popula1.Ind[i].Res)->ResDat=NULL; //[b]das Array, auf das der Zeiger zeigt, wird ständig in seiner Größe verändert(momentan mit realloc())[/b]
            (Popula1.Ind[i].Res)->NumPos=0;
            (Popula1.Ind[i].Res)->NumNeg=0;
            (Popula1.Ind[i].Res)->NumRes=0;
    }

Ich hoffe, ihr kommt mit dem code klar, er soll ja nur den inneren Aufbau verdeutlichen. Nun besteht mein Problem darin, dass diese Struktur sehr flexibel sein muss. Ich muss z.B. die Anzahl der Individuen variieren können. Das ist zwar mit den verketteten Strukturen auch möglich, bedeutet für mich aber bislang ein permanent umständliches allokieren/initialisieren/deallokieren von Speicher.
Darum frage ich: gibt es in C++ eine Möglichkeit diese Strukturen geschickter anzulegen?

Darum frage ich: gibt es in C++ eine Möglichkeit diese Strukturen geschickter anzulegen?

als einstieg: http://www.c-plusplus.net/forum/viewtopic-var-t-is-143816.html

Zunächst mal Dank für die Hilfe! Habe mir den Beitrag zu den containerklassen durchgelesen und bin nun bemüht, meinen code auf vectoren umzustellen. Vectoren scheinen eigentlich recht einfach handhabbar zu sein, nur hab ich sie noch nicht vollständig verstanden. Angenommen ich würde wie folgt einen vector deklarieren: vector<T> v. Es wird gesagt, dass ein vector automatisch mehr Speicher allokiert als nötig, damit nicht bei jeder Erweiterung reallokiert werden muss. Wie groß wäre somit solch ein vector, wieviele Elemente könnte ich vom Typ T nun anfügen, ohne den vector erweitern zu müssen? Wie wird bestimmt/wie bestimmt man, wieviel mehr an Speichel allokiert wird?
Angenommen mein Datentyp T wäre eine Klasse, und der Klasse hätte ich einen Konstruktor mitgegeben. Wird dann für jedes neue Element dieser Konstruktor aufgerufen?

Ich hoffe, man nimmt es mir nicht übel, dass ich derartige Fragen poste. Sicherlich könnte ich mir diese Fragen auch per try&error selbst beantworten, nur hoffe ich, dass ich somit schneller ans Ziel komme.

Dank im Voraus!!!

Angenommen ich würde wie folgt einen vector deklarieren: vector<T> v. Es wird gesagt, dass ein vector automatisch mehr Speicher allokiert als nötig, damit nicht bei jeder Erweiterung reallokiert werden muss. Wie groß wäre somit solch ein vector, wieviele Elemente könnte ich vom Typ T nun anfügen, ohne den vector erweitern zu müssen?

Am Anfang wird der Vector wohl fast keinen Speicher reservieren. Eine übliche Implementierung sieht so aus, dass die Kapazität (reservierter Speicher) jeweils verdoppelt wird, wenn sie nicht mehr ausreicht. Du kannst diese mit der Memberfunktion capacity() abfragen.

LoKi.aK schrieb:

Wie wird bestimmt/wie bestimmt man, wieviel mehr an Speichel allokiert wird?

Wirklich bestimmen kannst du das nicht. Du kannst aber Einfluss nehmen, indem du reserve() einsetzt - dann stellt der std::vector mindestens so viel Speicher zur Verfügung. Genaueres erfährst du unter www.cplusplus.com - das sollte bei dir das Nachschlagewerk zur Standardbibliothek sein.

LoKi.aK schrieb:

Angenommen mein Datentyp T wäre eine Klasse, und der Klasse hätte ich einen Konstruktor mitgegeben. Wird dann für jedes neue Element dieser Konstruktor aufgerufen?

Kommt drauf an. Wenn du zum Beispiel einen std::vector mit 12 Elementen erstellst, wird für diese der Standardkonstruktor aufgerufen. Übergibst du zusätzlich einen Wert, mit dem die 12 Elemente initialisiert werden sollten oder fügst du etwas nachträglich ein, kommt der Kopierkonstruktor zum Zug.

LoKi.aK schrieb:

Ich hoffe, man nimmt es mir nicht übel, dass ich derartige Fragen poste. Sicherlich könnte ich mir diese Fragen auch per try&error selbst beantworten, nur hoffe ich, dass ich somit schneller ans Ziel komme.

Nein, bestimmt nicht, solche Fragen sind völlig okay. Was ich zum Beispiel nicht besonders mag, sind absolute Anfängerfragen, die nur aus Faulheit resultieren, sich mit Theorie zu beschäftigen. Oder Fragen, die zwei Posts vorher beantwortet wurden. Aber mach dir da keine Gedanken, da sehe ich keine Probleme bei dir...

P.S. std::vector ist nicht der einzige Container der Standardbibliothek. In sichadats Link werden die STL-Container einander gegenübergestellt und die Vor- und Nachteile jeweils abgewogen.

Außerdem sollte dir klar sein, dass so bald du die C++-Standard-Bibliothek nutzt, du deine C-Konformität verlierst...

bb

Thx for your support! Aber ich hab da mal wieder ne Frage: Warum/Wofür brauche ich diesen Kopierkonstruktor überhaupt? Allgemein nimmt der Kopierkonstruktor eine Referenz auf ein Objekt desselben Typs als Parameter entgegen und hat die Aufgabe, eine Kopie des Objektes zu erstellen. Aber welche Bedeutung kommt ihm in Bezug auf Vektoren zu???
Brauche ich einen speziellen Kopierkonstruktor, oder reicht der Standardkopierkonstruktor, der ja doch vom Compiler scheinbar selbst angelegt wird? Oder reicht dieser nicht, weil er zu den "flachen" Kopierkonstruktoren zählt? Auf den Begriff flach/tief bin ich bei Wikipedia gestossen(http://de.wikipedia.org/wiki/Kopierkonstruktor). Es werden zwei Beispiele zu jeweils einer Art von Konstruktor gegeben. Mein Problem beim zweiten Bsp für den flachen Kopierkonstruktor ist, dass in meinen Augen auch hier eine echte Kopie erstellt wird, da mit new char[] ein separater Speicherbereich existiert.

Dank im Voraus!

Aber ich hab da mal wieder ne Frage: Warum/Wofür brauche ich diesen Kopierkonstruktor überhaupt? Allgemein nimmt der Kopierkonstruktor eine Referenz auf ein Objekt desselben Typs als Parameter entgegen und hat die Aufgabe, eine Kopie des Objektes zu erstellen. Aber welche Bedeutung kommt ihm in Bezug auf Vektoren zu???

Nehmen wir an, du hast irgendwelche Objekte, die du in den Container einfügen willst.

MyClass obj1, obj2;

Nun willst du beim Einfügen, dass innerhalb des Containers eine Kopie gespeichert wird und du die Originale unabhängig davon weiter benutzen kannst. Also rufst du push_back() auf, und der Container kopiert die Werte und speichert die Kopien. Die Originale bleiben unverändert.

std::vector<MyClass> Vec;
Vec.push_back(obj1);
Vec.push_back(obj2);

LoKi.aK schrieb:

Brauche ich einen speziellen Kopierkonstruktor, oder reicht der Standardkopierkonstruktor, der ja doch vom Compiler scheinbar selbst angelegt wird? Oder reicht dieser nicht, weil er zu den "flachen" Kopierkonstruktoren zählt? Auf den Begriff flach/tief bin ich bei Wikipedia gestossen(http://de.wikipedia.org/wiki/Kopierkonstruktor). Es werden zwei Beispiele zu jeweils einer Art von Konstruktor gegeben. Mein Problem beim zweiten Bsp für den flachen Kopierkonstruktor ist, dass in meinen Augen auch hier eine echte Kopie erstellt wird, da mit new char[] ein separater Speicherbereich existiert.

Der compilergenerierte Kopierkonstruktor (sowie auch der Zuweisungsoperator) kopiert Element für Element. Du musst dir überlegen, ob das für deine Klasse ausreicht. Hast du zum Beispiel einen Zeiger auf dynamisch allokierten Speicherbereich, so wird nur der Zeiger - und nicht der Speicherbereich - kopiert. Also musst du den Kopierkonstruktor selbst implementieren.

Sobald du Kopierkonstruktor, Zuweisungsoperator oder Destruktor selbst implementierst, musst du dich grundsätzlich auch um die anderen beiden kümmern (rule of the big three), damit dein Verhalten definiert bleibt.

Hab nun meine Header-/Quelldatei wie folgt aufgesetzt:

class SingleRes
{
    public:
        int x;
        int y;
        int pol;

    public:
        SingleRes();
        SingleRes(const SingleRes& rhs);
        SingleRes& operator=(const SingleRes& rhs);
        ~SingleRes();
}

#include "SingleRes.h"

//using namespace std;

//DefaultKonstruktor
SingleRes::SingleRes()
{
    x=0;
    y=0;
    pol=0;
}

//Kopierkonstruktor
SingleRes::SingleRes(const SingleRes& rhs)
{
    x=rhs.x;
    y=rhs.y;
    pol=rhs.pol;
}

//Operatorfunktion
SingleRes& SingleRes::operator=(const SingleRes& rhs)
{
    x=rhs.x;
    y=rhs.y;
    return *this;
}

//Destruktor
SingleRes::~SingleRes(){}

Eigentlich recht einfach, nur meckert mein Compiler:
12 C:\Users\LoKi.Ak\Desktop\StuffToday\C++\SingleRes.h expected ;' before '~' token 3 C:\\Users\\LoKi.Ak\\Desktop\\StuffToday\\C++\\SingleRes.cpp expected unqualified-id before "using" 3 C:\\Users\\LoKi.Ak\\Desktop\\StuffToday\\C++\\SingleRes.cpp expected,' or ;' before "using" 23 C:\\Users\\LoKi.Ak\\Desktop\\StuffToday\\C++\\SingleRes.cpp no \SingleRes& SingleRes::operator=(const SingleRes&)' member function declared in class `SingleRes'
30 C:\Users\LoKi.Ak\Desktop\StuffToday\C++\SingleRes.cpp no `SingleRes::~SingleRes()' member function declared in class `SingleRes'

Erkennt jemand von Euch meinen Fehler?

Thx

Ich hab nun nochmal Literatur gewälzt und die Methode des scharfen Hinsehens probiert, aber ich komme nicht dahinter, was bei mir falsch läuft. Vllt nimmt sich ja einer von Euch meiner an und wirft mal n Blick auf meinen code.

Zunächst die header-Datei:

class SingleRes
{
    public:
        int x;
        int y;
        int pol;

    public:
        SingleRes();
        ~SingleRes();
        SingleRes(const SingleRes& rhs);
        SingleRes& operator=(const SingleRes& rhs);
};

Dann die Quelldatei:

#include "SingleRes.h"

//DefaultKonstruktor
SingleRes::SingleRes()
{
    x=0;
    y=0;
    pol=0;
}

//Destruktor
SingleRes::~SingleRes(){}

//Kopierkonstruktor
SingleRes::SingleRes(const SingleRes& rhs)
{
    x=rhs.x;
    y=rhs.y;
    pol=rhs.pol;
}

//Operatorfunktion
SingleRes& SingleRes::operator=(const SingleRes& rhs)
{
    x=rhs.x;
    y=rhs.y;
    pol=rhs.pol;
    return *this;
}

Desweiteren soll in einer weiteren Klasse ein Vektor vom Typ der obigen Klasse deklariert(und somit auch definiert?) werden. Da die Elemente erst zur Laufzeit entstehen(und die Anzahl variiert), kann ich im Konstruktor nur einen Schätzwert über reserve() angeben. Seht Ihr bei meiner Konstruktion irgendwelche Gefahren auf mich zukommen? Hab ich den Kopierkonstruktor richtig aufgebaut?

headerDatei der zweiten Klasse:

#include <vector>
class ResSet
{
    public:
        int ResPos;
        int ResNeg;
        int ResSum;
        int Diff;

        vector<SingleRes> R;

    public:
        ResSet();
        ~ResSet();
}

Zu guter Letzt: es zeigt sich bei mir, dass ich ein und dieselbe Funktion in verschiedenen Klassen brauche. Muss ich die Funktion also mehrfach schreiben? Wahrscheinlich nicht. Löst man das Problem über Bibliotheken? Oder gliedert man die gemeinsam genutzten Funktionen aus-z.B. in eine Klasse MathOpera-und erzeugt in den jeweiligen Klassen Objekte dieser MathOpera-Klasse?

Ich hoffe, dass war jetzt nicht zuviel des Guten!!!

Dank im voraus!!!

Gibts alles schon

//edit zu deinem Code:
Deine erste Klasse sieht in Ordnung aus. Allerdings muss ich dir mitteilen, dass bis auf den default-Konstruktor alle Methoden so sind, wie sie der Compiler auch automatisch erzeugen würde. Du brauchst sie also nicht.

Ansonsten würde ich dir raten, die variablen private zu machen und dann mit get/set funktionen drauf zuzugreifen. Über das reserve beim vector solltest du dir keine Gedanken machen. Normalerweise kannst du es bedenkenlos ignorieren.

Sicher gibt es schon längst evolutionäre Algorithmen, denn noch möchte ich mich selbst auf dem Feld probieren. Einfach um ein paar Dinge nachvollziehen zu können.

Also, wenn mit meinem code alles soweit in Ordnung ist, warum spuckt der compiler die zuvor geposteten Fehlermeldungen aus?? Hab ich irgendein include vergessen? Am namespace kann es schliesslich auch nicht liegen.

Und inwieweit muss ich mir über das reserve keine gedanken machen? Ist es in Verbindung mit vectoren nicht ratsam die erwartete Kapazität anzugeben? Soweit ich weiss, nimmt das Erweitern des Vektors "viel" Zeit in Anspruch.

Gruss!!

Also, wenn mit meinem code alles soweit in Ordnung ist, warum spuckt der compiler die zuvor geposteten Fehlermeldungen aus?

Welchen Compiler nutzt du denn?

LoKi.aK schrieb:

headerDatei der zweiten Klasse:

Und inwieweit muss ich mir über das reserve keine gedanken machen? Ist es in Verbindung mit vectoren nicht ratsam die erwartete Kapazität anzugeben? Soweit ich weiss, nimmt das Erweitern des Vektors "viel" Zeit in Anspruch.

Wenn du ungefähr weisst, wie viel Speicherplatz der std::vector benötigt, ist reserve() okay. Aber wenn du zuerst eine komplizierte Abschätzung durchführen musst, mit der du dann trotzdem in der Hälfte der Fälle falsch liegst, überlässt du die Speicherverwaltung lieber dem std::vector . Eine Reallokation dauert erst spürbar lange bei wirklich vielen bzw. grossen Elementen, dafür kannst du in einigen Fällen Speicherplatz sparen.

Könnten die Fehlermeldungen mit meinem compiler zusammenhängen? Inwiefern?

Eine Reduzierung am Schluss auf die tatsächliche Kapazität sollte ja doch nicht kompliziert/aufwendig sein, da vectoren doch bei operationen auf die letzten elemente einen geringen(/konstanten) zeitaufwand haben!?!?

Nicht kompliziert, aber unmöglich. Ein std::vector gibt den angeforderten Speicher eigentlich erst im Destruktor wieder frei. Von daher solltest du vorsichtig sein mit präventiven Allokationen. Vielleicht besser, du überlässt das Speichermanagement dem std::vector .

Und die Operationen auf dem letzten Element haben eine (amortisiert) konstante Zeitkomplexität, jedoch gehen darunter eigentlich keine Reallokationen. Diese tragen nur zum "amortisiert" bei, in den meisten Fällen sind sie nicht nötig. Aber du kannst auch keinen Speicherbereich verkleinern, ohne ihn neu anzulegen.

Eine andre Frage, die wahrscheinlich in blutigste Anfängerkategorie gehört:
Ich habe in der Signatur(Übergabeparamter) zweier Funktionen zwei Variablen mit gleichem Namen deklariert, wobei die eine Funktion in der anderen aufgerufen wird. Soweit ich weiss, sind lokale Variable "gekapselt", d.h. die eine Variable in der inneren bekommt beim Durchlaufen ihrer Funktion nichts von der anderen in der äußeren Funktion mit. Oder kann es da doch zu Komplikationen kommen?

Zuletzt noch eine ältere Frage:
Es geht darum, dass ich ein und dieselbe Funktion in verschiedenen Klassen brauche. Muss ich die Funktion also mehrfach schreiben? Wahrscheinlich nicht. Löst man das Problem über Bibliotheken? Oder gliedert man die gemeinsam genutzten Funktionen aus-z.B. in eine Klasse MathOpera-und erzeugt in den jeweiligen Klassen Objekte dieser MathOpera-Klasse?

Sry, dass ich hier teilweise Anfängerfragen poste. Bin noch nicht lange dabei und bin bei vielem noch unsicher, da ich es nicht genau weiss!

Thx

Ich habe in der Signatur(Übergabeparamter) zweier Funktionen zwei Variablen mit gleichem Namen deklariert, wobei die eine Funktion in der anderen aufgerufen wird.

Sofern die Variablen in unterschiedlichen Scopes deklariert wurden (im gleichen Scope ist gar nicht möglich), benutzt du automatisch die des innersten Gültigkeitsbereiches, also quasi die lokalste. Innerhalb einer Funktion sind nur Parameter, globale und lokale Variablen bekannt - nicht aber die aus anderen Scopes.

LoKi.aK schrieb:

Es geht darum, dass ich ein und dieselbe Funktion in verschiedenen Klassen brauche. Muss ich die Funktion also mehrfach schreiben?

Nein. Mehrfach schreiben solltest du grundsätzlich nichts. Implementiere die Funktion wie von otze erwähnt als freie Funktion, eventuell in einem eigenen Namensraum. Es hat keinen Sinn, eine Klasse "MathOpera" zu erzeugen, die nur ein paar Funktionen zusammenfasst. Da machst du lieber einen namespace .