Ich muss eine reihe von Objekten einer Klasse erstellen.
Dies mache ich zurzeit mit einer schleife.

for (i,i>=anzahl,i++)

nun muss ich die Objekte ja bennen. ich wollte sie einfach durchnummerieren und dafür die Variable i nutzen, die jeweils einen Zahlenwert verdeutlicht.
Wie kann aber der Compiler unterscheiden ob es sich um eine Variable handelt??
Muss ich irgendetwas dazu schreiben??
ist das überhaupt so möglich einfach zu schreiben
ecke i;

(ecke ist die Klasse)

Vielen dank schon mal für die antworten

Nein, das ist SO nicht möglich. Aber schau dir mal new/delete an. Das dürfte etwa das sein, was du suchst.

Allerdings hat das Problem nicht allzuviel mit new/delete zu tun.

for (i,i>=anzahl,i++)

Wie willst du sonst eine variable Menge von Objekten erstellen, wenn nicht mit new?

Wie willst du sonst eine variable Menge von Objekten erstellen, wenn nicht mit new?

#include <string>
#include <vector>
#include <iostream>

int _main(int argc, _TCHAR* argv[])
{

	std::vector<std::string> v;
	for (int i = 0; i <10; ++i)
	{
		std::string s = "Das ist ein Objekt auf dem Stack";
		v.push_back(s);
	}

	for(std::vector<std::string>::const_iterator it = v.begin();
		it != v.end();
		++it)
	{
		std::cout << *it << std::endl;
	}

	return 0;
}

Du könntest das ganz einfach über ein Array lösen (ungetestet):

const size_t anzahl = 10000;
Vertex* vertices = new Vertex[anzahl];

for(size_t i = 0; i < anzahl; ++i) {
    vertices[i] = Vertex(0.0f, 0.0f, 0.0f);
}

delete[] vertices;

Grüße... Heiko

Wie willst du sonst eine variable Menge von Objekten erstellen, wenn nicht mit new?

#include <string>
#include <vector>
#include <iostream>

int _main(int argc, _TCHAR* argv[])
{

	std::vector<std::string> v;
	for (int i = 0; i <10; ++i)
	{
		std::string s = "Das ist ein Objekt auf dem Stack";
		v.push_back(s);
	}

	for(std::vector<std::string>::const_iterator it = v.begin();
		it != v.end();
		++it)
	{
		std::cout << *it << std::endl;
	}

	return 0;
}

Sorry, habe schon einen Schritt zu weit gedacht.

bwbg schrieb:

const size_t anzahl = 10000;
Vertex* vertices = new Vertex[anzahl];

for(size_t i = 0; i < anzahl; ++i) {
    vertices[i] = Vertex(0.0f, 0.0f, 0.0f /* Sollen das Koordinaten sein ?? oder habe ich da was vergessen ...*/); 
}

delete[] vertices;  // kann ich auch schreiben delete vertices [objektnr.] ??

Also ich habe ein Objekt Vertex (bei mir ecke) und in diesem erstelle als Array anzahl an Objekten der klasse vertex.
Die Objekte kann ich dann jeweils per vertices[objektnr] ansprechen
Richtig??

Zuer erklärung was ich mache, es handelt sich um Graphen. Bei denen ist die Koordinate zumindest in meinem falle egal. es geht nur um die Verbindungen zwischen den ekcen (diese werden später als eigenschaften angegeben)
Durch einen bestimmten algorithmus wird dann herausgefunden, ob z.B. eine Euler Tour (alle Kanten entlang "laufen" und am ausgangspunkt ankommen)oder ein Eulerscher Kantenzug möglich ist und deren variationen

Der Aufruf Vertex(0.0f, 0.0f, 0.0f) ist in diesem Fall der Konstruktoraufruf.

Mittels dem Indexoperator [] kannst du auf die Elemente des Arrays zugreifen. Du musst allerdings selbst dafür sorgen, dass der Bereich nicht überschritten wird (Segmentation-Faults wären noch die angenehmste Folge einer Überschreitung).

Wichtig zu wissen ist, dass new lediglich Speicher anfordert. Mit delete gibst du den (mit new) angeforderten Speicher wieder frei (was man immer tun MUSS).

Wenn du mehr Flexibilität benötigst, solltest du dir die oben schon angesprochenen Standardcontainer-Klassen (std::vector, std::list, etc.) mal ansehen - diese nehmen dir auch die Speicherverwaltung ab.

Grüße...

void neueecken()
	{
	cout << "Beginnen wir mit der Erfassung der Ecken." << endl
	<< "Sie können später alle Ecken nachbearbeiten."<< endl
	<< "merken sie sich dafür einfach die Nr. der Ecke." << endl
	<< "Diese wird vom Programm jeweils bekannt gegeben." << endl;
	cout << "Wie viele Ecken möchten sie erstellen?";
	size_t anzahl;
	cin >> anzahl;	cout << anzahl << endl;
	ecke* vertices = new ecke[anzahl];

	for (i=0,i>=int(anzahl),i++)
		{
		cout << "Beginnen wir mit der" << i << ".-Ecke." << endl;
		cout << "Wie viele Verbindungen (Kanten) besitzt die Ecke?";
		cin >> vertices[i].grad; cout << vertices[i].grad << endl;
			for (b=0, b>= vertices[i].grad, b++)
			{
			cout << "Mit welchen weiteren Eckennummer soll die aktuelle Ecke verbunden werden?";
			int eckennr
			cin >> eckennr
			vertices[i].verbindung.push_back(eckennr); cout <<  vertices[i].verbindung[b] << endl;
			}
		cout << endl << endl << endl;
		}
	}

Vielen dank schon mal im Voraus

Überleg dir das:

for (i=0,i>=int(anzahl),i++)

mal noch genau.Und vor allem, was was genau macht.

Und warum hast du das den noch nicht selber getestet??

EDIT:

Dasselbe gilt für die 2. for-Schlaufe.

for (i=0,i>=int(anzahl),i++)
      1        2         3

1.: size_t i (0) bzw. size_t i = 0 (wobei ich die Initialisierung mit Klammern besser find ) (sonst würde dir der compiler sagen, dass er 'i' nicht kennt... da i dann auch von size_t ist, entfällt der doofe (c-style-)cast (solltest du dir auch abgewöhnen)
2.: hier kommt nicht hin, wann er aufhören soll, sondern wann er weitermachen soll (verzeiht mir diesen Satz ^^) mit >= würde niemals (außer, wenn man 0 ecken eingegeben hat, dann 1 ^^) auch nur 1 Schleifendurchlauf zu Stande kommen -> i < anzahl - sollte nicht all zu unlogisch sein ^^ (nicht <=, weil ja die 0 mit dabei ist ^^)
3.: ++i - man zieht preincrement vor - das macht hier noch nichts aus, aber wird spätestens bei iteratoren schneller sein...

soo... ok?

Danke aber für die große hilfe bis hierher

Falls fragen aufkommen, oder noch anmerkungen zum quellcode oben sind, wird man mich hier finden.