hoffe dass man mir hier weiterhelfen kann. Ich möchte mir eine Klasse erzeugen in der ich am liebsten ein dynamischen Array von Punkten habe. Momentan habe ich es statisch erzeugt. Problematik dabei ist, dass ich auch ein Array von der Klasse anlegen möchte, denn beide größen (anzahl der Strukturen, sowie anzahl der Punkte in der Struktur) lese ich aus einer Datei.
In meiner Version lese ich die Datei gleich 2x. Zum ersten mal um die anzahl auszulesen und im zweiten Durchlauf wird dann erst richtig eingelesen. Jedoch bekomme ich einen Compiler-fehler, was auch sonst.

///// MAIN 
int main(int argc, char *argv[]) {
...
	error = read_parameter(&numStructures, &maxPoints, &width, &height, argv[1]);

	Elem Structures[numStructures];
	error = read_structures(&Structures, maxPoints, argv[1]);
...
}

///// Function
int read_Structures(Elem **Strukturen, int maxPoints, char *infile){

... /*lese werte ein und merke auf Struktur t */

	(*Strukturen)[structureID] = t;
...
}/* read_structures */

///// Class
class Elem{

	...
private:
	int id;
	char *name;
	int numPnt;
	Pnt *points;
};

Die Fehlermeldung lautet:
Multiple markers at this line
- cannot convert `Elem ()[((numStructures - 1) + 1)]' to `Elem**' for argument `1' to `int
read_structures(Elem**, int, char)'
- Line breakpoint: Main.cpp

Hoffe ihr habt ne Idee oder alternative Vorschläge

Danke schonmal

1. Den kompletten Code und Fehlermeldungen mit Zeilenangaben posten.
2. Klassen, die in main() verwendet werden, müssen vorher bereits bekannt sein.

#ifndef KLASSEN_H_
#define KLASSEN_H_

#include <string>
using namespace std;

class Pnt{
public:
	Pnt(void){x=0;y=0;}
	Pnt(int i, int j){x=i;y=j;}
	Pnt(const Pnt& rhs){x=rhs.x; y=rhs.y;}
	int get_x(void){return x;}
	int get_y(void){return y;}
	void set_x(int i){x=i;}
	void set_y(int j){y=j;}

private:
	int x;
	int y;
};

class Elem{
public:
	//default constructor
	Elem(void){id=0; name=""; numPnt=0;}
	//constructor
	Elem(int MAXPNT){numPnt=MAXPNT; create_Pnts(numPnt);}
	//copy constructor
	Elem(const Elem& rhs){id=rhs.id; name=rhs.name; numPnt=rhs.numPnt;}
	//destructor
	~Elem(void){}

	void  set_name(char *NAME){name=NAME;}
	char* get_name(void){return name;}
	void set_id(int ID){id=ID;}
	int  get_id(void){return id;}
	void set_numPoints(int numPoints){numPnt=numPoints;}
	int  get_numPoints(void){return numPnt;}
	void add_pnt(Pnt P, int POS){points[POS]=P;}
	Pnt  get_pnt(int pos){return points[pos];}

private:
	int id;
	char *name;
	int numPnt;
	Pnt *points;

	void create_Pnts(int n){
		if (points){delete points;}
		points = new Pnt[n];
	}
};

#endif /*KLASSEN_H_*/

#ifndef EINLESEN_H_
#define EINLESEN_H_

int toktoi(char *);
int read_parameter(int*, int*, int*, int*, char*);
int read_structures(Elem**, int, char*);

#endif /*EINLESEN_H_*/

///// Einlesen.c
#include <iostream>
#include <fstream>
#include <string>
using namespace std;

#include "Klassen.h"

#ifndef BUFLEN
#define BUFLEN 8000
#endif

... //hier habe ich nur 2 Funktionen stehen die für das Problem irrelevant sind

int read_Structures(Elem **Strukturen, int maxPoints, char *infile){

	ifstream xmlfile;
	char buf[BUFLEN];
	char *token;
	char separator[] = " <>"; //benutzte Trennzeichen
	enum status { 	structure,
					trace,
					point}status;
	int structureID;
	char name[30];
	int numPoints;
	Elem t;
	Pnt p;
	int pos;

	status = structure;

	xmlfile.open(infile, ios::in);
	while(!xmlfile.eof()){
		//liest zeilenweise von xmlfile
		xmlfile.getline(buf,BUFLEN);

		//splittet den Buffer in einzelne Tokens
		token = strtok(buf, separator);

		while(token!=NULL){

			Elem t(maxPoints);

			switch (status){				
			case structure:				
				if(!strncmp(token, "structureID", 11)){
					structureID = toktoi(token);
					t.set_id(structureID);
				}
				else if(!strncmp(token, "name", 4)){
					for(unsigned int i=6;i<(strlen(token)-1);++i){
						name[i-6]=token[i];
						name[i-5]='\0';
					}
					t.set_name(name);
				}
				else if(!strcmp(token, "Trace")){
					status = trace;
				}
				break;

			case trace:
				if(!strncmp(token, "numPoints", 9)){
					numPoints = toktoi(token);
					t.set_numPoints(numPoints);
				}
				else if(!strcmp(token, "Point"))
					status = point;
				else if(!strcmp(token, "/Trace"))
					status = structure;
				break;

			case point:
				pos = toktoi(token);
				token = strtok(NULL, separator);
				p.set_x(toktoi(token));
				token = strtok(NULL, separator);
				p.set_y(toktoi(token));
				token = strtok(NULL, separator);
				t.add_pnt(p,pos);
				if(!strcmp(token, "/Point")){
					status = trace;
				}
				break;

			default:
				break;

			(*Strukturen)[structureID] = t;
			}
			token = strtok(NULL, separator);
		}
	}
	xmlfile.close();

	return EXIT_SUCCESS;
}/* read_structures */

///// Main
#include <iostream>
#include <fstream>
#include <string>
using namespace std;

#include "Klassen.h"
#include "Einlesen.h"
//#include "Routine.h"

int main(int argc, char *argv[]) {

	int error;

	int numStructures = 1;
	int maxPoints = 1;
	int width = 1;
	int height = 1;
	error = read_parameter(&numStructures, &maxPoints, &width, &height, argv[1]);

	Elem Structures[numStructures];
	error = read_structures(&Structures, maxPoints, argv[1]);

	return EXIT_SUCCESS;
}

Ich weiss, dass das nicht ganz sauber ist, aber die eingabedatei ist fest strukturiert und es fluppte auch. Der Fehler trat erst nach dem modularisieren auf, sprich als ich die einzelnen Datei-Module erzeugt habe. Daher müßte das ein Parameterfehler im Funktionsaufruf sein.

Hier nochmal der Compilerfehler:
cannot convert `Elem ()[((numStructures - 1) + 1)]' to `Elem**' for argument `1' to `int read_structures(Elem**, int, char)'

#if !defined(ELEMENT_HPP__INCLUDED)
#define ELEMENT_HPP__INCLUDED

#if (_MSC_VER >= 1300)
#pragma once
#endif // (_MSC_VER >= 1300)

#include <string>
#include <vector>

class Element
{
public:
    Element()
        : m_id(0)
    {}

public:
    void set_name(const char* name) { m_name = name;}
    const char* get_name() const { return m_name.c_str(); }

    void set_id(unsigned int id) { m_id = id; }
    unsigned int  get_id() const { return id; }

    const std::size_t get_point_count() const { return m_data.size(); }

    void add_point(Point const& point) { m_data.push_back(point); }
    Point const&  get_point(const std::size_t pos) { return m_data.at(pos); }

private:
    unsigned int m_id;
    std::string m_name;
    std::vector<Point> m_data;
};

#endif // ELEMENT_HPP__INCLUDED

So. Deine Klasse war katastrophal falsch! Du reservierst andauernt speicher, gibst diesen nicht frei und greifst auf Bereiche zu ohne zu Prüfen ob diese im Range sind. Dann hälst du dich natürlich nicht an die const correctness und lässt jeden deine !private-Daten bearbeiten.