#pragma once

#include <algorithm>
#include "Color.h"

const Color yellow = Color ( 1.0f, 1.0f, 0.0f, 1.0f );
const Color orange = Color ( 1.0f, 0.5f, 0.0f, 1.0f );
const Color green  = Color ( 0.0f, 1.0f, 0.0f, 1.0f );
const Color red    = Color ( 1.0f, 0.0f, 0.0f, 1.0f );
const Color blue   = Color ( 0.4f, 0.4f, 1.0f, 1.0f );
const Color black  = Color ( 0.0f, 0.0f, 0.0f, 1.0f );

enum Side
{
	Front = 1, Left = 2, Back = 3, Right = 4, Top = 5, Bottom = 6
};

enum Edge
{
	ELeft, ETop, ERight, EBottom, Non
};

class Stone{
	...
};

Hier bekomme ich folgende Fehlermeldung, die auf die Klasse Color zurück fällt:

322 IntelliSense: Aufruf eines Objekts eines Klassentyps ohne entsprechenden ()-Operator oder Konvertierungsfunktionen für Typ "pointer-to-function"

Die Klasse Color sieht folgendermaßen aus:

#include "glut.h"

class Color
{
	public:
		float red, green, blue, alpha;
		Color() {  }		
		Color(float red, float green, float blue, float alpha);
		//Color(const Color& orig);

		void drawColor();
		void setColor(const Color& color);
		void exchangeColor(Color & color);
}

Jetzt ist das Interessante, dass die Fehlermeldung in der Klasse Stone nicht geworfen wird, wenn ich folgendes tue:

#pragma once

#include <algorithm>
#include "Color.h"

; // <<<<<<<<<<<<<<<<<<<---------------------------------------

const Color yellow = Color ( 1.0f, 1.0f, 0.0f, 1.0f );
const Color orange = Color ( 1.0f, 0.5f, 0.0f, 1.0f );
const Color green  = Color ( 0.0f, 1.0f, 0.0f, 1.0f );
const Color red    = Color ( 1.0f, 0.0f, 0.0f, 1.0f );
const Color blue   = Color ( 0.4f, 0.4f, 1.0f, 1.0f );
const Color black  = Color ( 0.0f, 0.0f, 0.0f, 1.0f );

enum Side
{
	Front = 1, Left = 2, Back = 3, Right = 4, Top = 5, Bottom = 6
};

enum Edge
{
	ELeft, ETop, ERight, EBottom, Non
};

class Stone{
	...
};

Mit dem Semikolon läuft auf einmal alles. Unerwünschter Nebeneffekt jedoch ist, dass keinerlei Operationen auf der Klasse Color mehr funktionieren. Nichteinmal der Konstruktor überträgt die Werte in die Membervariablen.

Color::Color(float red, float green, float blue, float alpha)
{
	Color::red = red;
	Color::green = green;
	Color::blue = blue;
	Color::alpha = alpha;
}

und wie ich jetzt gerade auf einmal sehe, bekomme ich auch in dieser Klasse eine neue Fehlermeldung...

321 IntelliSense: Der Rückgabetyp darf nicht in einem Konstruktor angegeben werden.

Den Header hab ich ja schon oben vorgeführt. Daher zeig ich hier eben noch einmal vorsichtshalber die ganze Klasse, falls ich da Mist gebaut habe... Der Fehler hier verweist irgendwie auf den ersten gleich aufgeführten Konstruktor.

#include "Color.h"

Color::Color(float red, float green, float blue, float alpha)
{
	Color::red = red;
	Color::green = green;
	Color::blue = blue;
	Color::alpha = alpha;
}

Color::Color(const Color& orig)
{
	Color::red = orig.red;
	Color::green = orig.green;
	Color::blue = orig.blue;
	Color::alpha = orig.alpha;
}

void Color::drawColor()
{
	glColor4f(red,green,blue,alpha);
}

void Color::setColor(const Color& color)
{
	red = color.red;
	green = color.green;
	blue = color.blue;
	alpha = color.alpha;
}

void Color::exchangeColor(Color & color)
{
	float temp;
	temp = red;
	Color::red = color.red;
	color.red = temp;

	temp = green;
	Color::green = color.green;
	color.green = temp;

	temp = blue;
	Color::blue = color.blue;
	color.blue = temp;

	temp = alpha;
	Color::alpha = color.alpha;
	color.alpha = temp;
}

Danke schonmal im Voraus

class Color
{
    ...
}; // <---

Allerdings hab ich jetzt noch ein aller letztes Problem. ICh definiere in meiner Klasse Stone Konstanten der Klasse Color die ich auch direkt initialisiere. Wenn ich diese Objekte dann später alle verwenden will, befinden sich nur noch 0-Werte in den einzelnen Variablen für rot grün und blau.

also ich habe den Header meiner Klasse Stone, in dem ich die Konstanten setze.

#pragma once

#include <algorithm>
#include "Color.h"

		const Color yellow = Color ( 1.0f, 1.0f, 0.0f, 1.0f );
		const Color orange = Color ( 1.0f, 0.5f, 0.0f, 1.0f );
		const Color green  = Color ( 0.0f, 1.0f, 0.0f, 1.0f );
		const Color red    = Color ( 1.0f, 0.0f, 0.0f, 1.0f );
		const Color blue   = Color ( 0.4f, 0.4f, 1.0f, 1.0f );
		const Color black  = Color ( 0.0f, 0.0f, 0.0f, 1.0f );
enum Side
{
	Front = 1, Left = 2, Back = 3, Right = 4, Top = 5, Bottom = 6
};

enum Edge
{
	ELeft, ETop, ERight, EBottom, Non
};

class Stone{
	public:
		Color color1, color2, color3;
		enum Side side;
		Edge edge1, edge2;
		bool StoneUsed;

		Stone();		
		Stone(Side side, Edge edge1, Edge edge2);

		void overrideStone(const Stone& stone );
		void exchangeColors(Stone& s);
		void switchEdgesXZ();
		void switchEdgesYZCorner();
		void switchEdgesXYCorner();
	private: 
		void getSideColor(Side side, Edge edge1, Edge edge2);
		void getEdgeColor(Side side, Edge edge1, Edge edge2);
		void getFrontCornerColors(Edge edge1, Edge edge2);
		void getLeftCornerColors(Edge edge1);
		void getRightCornerColors(Edge edge1);
		void getBackCornerColors(Edge edge1, Edge edge2);
		void getTopColors();
		void getBottomColors();
};

Wenn ich dann allerdings im Konstruktor von Stone den Inhalt der Variable green abfrage, ist dieser einfach nur in jedem Feld 0 und ich bekomme nicht heraus, woran das liegt

Stone :: Stone(Side side, Edge edge1, Edge edge2){
	Stone::side = side;
	Stone::edge1 = edge1;
	Stone::edge2 = edge2;

		printf("green = %f, %f, %f \n",green.r, green.g, green.b);

	Stone::StoneUsed = true;

	getSideColor(side,edge1,edge2);
}

Ausgabe:: green = 0.000000, 0.000000, 0.000000

Wie die Klasse Color aussieht, kann man am vorherigen Post noch sehen. ICh hab nur die Variablen in r,g,b,a umbenannt.

Danke ^^

Bitte dritten Link in meiner Signatur lesen!

P.S.: Guck dir mal an, was eine Initialisierungsliste ist!

Okay, dann hab ich nur noch um so weniger Plan, wieso es nicht funktioniert.
Aber wenn du schon sagst, dass es klappt, wenn du alle offensichtlichen Fehler eliminierst, wäre das ja vielleicht mal ein Ansatz... Ich wüsste jetzt nichts von offensichtlichen Fehlern...

Na das Semikolon, die nicht zueinander passenden Bezeicher...

So das es überhaupt compiliert.

Wie gesagt: Dritter Link in meiner Signatur. Du hast deinen Fehler anscheinend beim Posten herausgekürzt, dafür erschlägst du uns mit hunderten von irrelevanten Zeilen.

std::vector<std::vector<std::vector<Stone>>> cube;
// Diesen Vektor initialisiere ich später, werde ich hier aber nicht merh mit angeben

Dann kommt als nächstes

string col;
	Color color = Color(green);
	col = identifyColor(color);

	printf("%s \n",col.c_str());
	printf("%f, %f, %f \n",green.r, green.g, green.b);
	printf("-------------------------------\n");

// Hier wird ganz offensichtlich der Konstruktor von Stone aufgerufen.
	cube.at(0).at(0).at(0) = Stone(Front, ELeft, ETop);

	col;
	color = Color(green);
	col = identifyColor(color);

	printf("%s \n",col.c_str());
	printf("%f, %f, %f \n",green.r, green.g, green.b);
	printf("-------------------------------\n");

hier gehts dann weiter

Stone :: Stone(Side side, Edge edge1, Edge edge2){
        ...

	printf("%f, %f, %f \n",green.r, green.g, green.b);
		printf("-------------------------------\n");

	getSideColor(side,edge1,edge2);

	printf("%f, %f, %f \n",green.r, green.g, green.b);
		printf("-------------------------------\n");
}

und die Ausgabe auf der Konsole ist folgende:

green
0.000000, 1.000000, 0.000000
-------------------------------
0.000000, 0.000000, 0.000000
-------------------------------
0.000000, 0.000000, 0.000000
-------------------------------
green
0.000000, 1.000000, 0.000000
-------------------------------

also aus irgendeinem Grund spackt er rum, wenn die Klasse Stone aufgerufen wird. Vorher und nachher ist ja alles okay...
Hat irgendwer einen Plan, wieso sowas passieren kann?

Die Headerdatei Cube.h

#pragma once

#include "Stone.h"
#include <string>
#include <vector>

class Cube{
	public:
		std::vector<std::vector<std::vector<Stone>>> cube;
		int cubesize;
		Cube() {  }
		Cube(int cubesize);
		static std::string identifyColor(Color& color);
	private:
		bool isCorner(int x, int y, int z);
		void setStone(int x, int y, int z);		
};

Die entsrechende .cpp Datei

#include "Cube.h"

using namespace std;

	Cube :: Cube(int sizeOfCube)
	{
		cubesize = sizeOfCube;

		for(int x = 0; x < cubesize; x++)
		{
			vector<vector<Stone>> side (cubesize);
			cube.push_back(side);
			for(int y = 0; y < cubesize; y++)
			{
				vector<Stone> line (cubesize);
				cube.at(x).push_back(line);
				for(int z = 0; z < cubesize; z++)
				{   
					cube.at(x).at(y).push_back(Stone());
				}				
			}
		}

		// Stein vorne oben links mit Farben grün-rot-gelb

		string col;
		Color color = Color(green);
		col = identifyColor(color);

		printf("%s \n",col.c_str());
		printf("%f, %f, %f \n",green.r, green.g, green.b);
		printf("-------------------------------\n");

		cube.at(0).at(0).at(0) = Stone(Front, ELeft, ETop);

		col;
		color = Color(green);
		col = identifyColor(color);

		printf("%s \n",col.c_str());
		printf("%f, %f, %f \n",green.r, green.g, green.b);
		printf("-------------------------------\n");
	... // alles darunter ist aktuell auskommentiert

und obwohl der Rest durch oben schon bekannt ist, füg ich es trotzdem nochmal hinzu, damit man sich das Scrollen sparen kann

#pragma once

#include "Color.h"
#include <algorithm>

		const Color yellow = Color ( 1.0f, 1.0f, 0.0f, 1.0f );
		const Color orange = Color ( 1.0f, 0.5f, 0.0f, 1.0f );
		const Color green  = Color ( 0.0f, 1.0f, 0.0f, 1.0f );
		const Color red    = Color ( 1.0f, 0.0f, 0.0f, 1.0f );
		const Color blue   = Color ( 0.4f, 0.4f, 1.0f, 1.0f );
		const Color black  = Color ( 0.0f, 0.0f, 0.0f, 1.0f );

enum Side
{
	Front = 1, Left = 2, Back = 3, Right = 4, Top = 5, Bottom = 6
};

enum Edge
{
	ELeft, ETop, ERight, EBottom, Non
};

class Stone{
	public:
		Color color1, color2, color3;
		Side side;
		Edge edge1, edge2;
		bool StoneUsed;

		Stone();		
		Stone(Side side, Edge edge1, Edge edge2);

		... // das ist alles unwichtig
};

Stone :: Stone(Side side, Edge edge1, Edge edge2){
	... // nur initialisierungen	

	printf("%f, %f, %f \n",green.r, green.g, green.b);
		printf("-------------------------------\n");

	getSideColor(side,edge1,edge2);

	printf("%f, %f, %f \n",green.r, green.g, green.b);
		printf("-------------------------------\n");
}

... // auch alles uninteressant

Und die Klasse Color is ja klar. Hattest du ja auch schon getestet.

Im Prinzip wird nur ein Objekt der Klasse Cube erzeugt und im Folgenden gehts halt schief...

Ich werd stattdessen einfach mal deinen beitrag von vorher ignorieren und werde jetzt mal die entsprechenden Codestücke posten die ich dazu habe.

Ja, das ist eine sehr zielorientierte Methode . Wenn man denn mal 15 Minuten investiert hat, um deinen Dreck zum laufen zu bekommen, dann funktioniert's auch:
http://ideone.com/JHc2K

Da du offensichtlich nicht willens bist, irgendetwas selber zu tun, sondern darauf wartest, bis dir irgendein Mitleidiger deine Probleme wegzaubert, verabschiede ich mich mal aus dem Thread...