ich habe probleme mit dem Zugrif auf Structs. Ich versuche was in OpenGL zuschreiben, ich möchte die Koordinaten, die ich mit der Maus bestimme in einen Vector abspeichern.
Ich also folgendes vorliegen:

struct point
{
	int x,y;
};

using namespace std;

vector<point> punktliste;

void speichern(int x, int q)
{	
		point punkt = (x,q);
		punktliste.push_back(punkt);
}

ich ,öchte nun auf meinen Struct zugreifen und die Koordinaten in meinen Vector abpeichern.

void polyline(GLint button, GLint action, GLint xMouse, GLint yMouse) //Mouse callback prozedur
{
	static point endPt1, endPt2;
	static float x,y;
	struct point a;

	if(button == GLUT_RIGHT_BUTTON && action == GLUT_DOWN)
		{
			endPt1.x = xMouse;
			endPt1.y = winHeight - yMouse;

			cout<<endPt1.x<<"\n" ;
			cout<<endPt1.y<<"\n";

			a.x = endPt1.x ;
			a.y = endPt1.y;

			drawLineSegment(endPt1, endPt2);
			speichern(a.x, a.y);
			glFlush();
			drawLine(endPt1, endPt2);
			glFlush();				
	}
	else

Ich bekomme aber immer die Fehlermeldung:
error C2440: 'initializing' : cannot convert from 'int' to 'struct point'

Kann mir mal jemand sagen was ich falsch mache ?

Grüße

Du hast in speichern die falschen Klammern.
Das hier

point punkt = (x,q);

sollte so aussehen

point punkt = {x,q};

Noch besser wäre es hier aber, wenn du point einen Konstruktor spendierst der die Initialisierung übernimmt.

struct point
{
    int x,y;
    point(int x_, int y_) : x(x_), y(y_) {}
};
// dann
void speichern(int x, int q)
{   
    punktliste.push_back(point(x,q));
}

Die Funktion speichern könnte man jetzt auch gleich ganz weglassen.

also ich danke Dir erstmal, aber das mit Konstruktor gibt mir andauernd ne Fehlermeldung so dass ich das weggelassen habe, mein Prolem ist nun, ich kann zwar etwas in meinen Vector schreiben, aber ich mein das ist alles andere als Koordinaten.

144055072
144055080

anstelle von (362,176)

kannst Du mir vielleicht sagen warum das so ist ?

#include <vector>       // STL-vector
  #include <algorithm>	

#include <GL/glut.h>
#include <glu.h>
#include <iostream>

GLsizei winWidth = 700;
GLsizei winHeight = 400;

 static float array[10][10];
 float erste[2];

 bool flag = false;

bool blnAction = false;

class polygon
{
public:
	GLint x,y;

};

struct point
{
	int x,y;
	//point(int x_, int y_) : x(x_), y(y_) {}

}; 
//	punktliste.push_back(punkt);

using namespace std;

vector<point> punktliste;

void speichern(int x, int q)
{
	cout<<"hier    "<<x<<"\n";
	cout<<"hier    "<<q<<"\n";

	point punkt = {x,q};

		punktliste.push_back(punkt);		
}

void init()
{
	glClearColor(0.0, 0.0, 1.0, 1.0);  // set Window Color to blue Hintergrundfarbe
	glMatrixMode(GL_PROJECTION);       //Art des Koordinatensystems
	gluOrtho2D(0.0, 200.0, 0.0, 150.0);////Koordinatenverteilung festlegen
                                             //x-> 0.0 ... 200.0                                             //y- > 0.0 ... 150.0
}

void displayFcn(void)
{
	glClear(GL_COLOR_BUFFER_BIT);      //Fenster löschen
	glPointSize(5.0);
	glLineWidth(1.75);

}

void winReshapeFcn(GLint newWidth, GLint newHeight)
{
	glViewport(0,0,newWidth, newHeight);
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	gluOrtho2D(0.0,GLdouble(newWidth),0.0,GLdouble(newHeight));

	winWidth = newWidth;
	winHeight= newHeight;
}

void drawPolygon(polygon endPt1, polygon endPt2)
{
	glBegin(GL_POLYGON);

	glVertex2i(endPt1.x,endPt2.y);
}

void draw()
{

	std::vector<point>::iterator i = punktliste.begin();

	for ( i=punktliste.begin(); i != punktliste.end(); ++i ){

		cout<<(int)i<<"\n";

	}
}
/*
void draw_polygons()
{
  std::vector<point>::iterator i = polygons.begin();
  while(i != poligons.end())
  {
    glBegin(GL_POLYGON);

    std::vector<line_t>::iterator j = (*i).lines;
    while(j != (*i).lines.end())
    {
       glVertex2i( (*j).from.x, (*j).from.y);
       glVertex2i( (*j).to.x, (*j).to.y);
       ++j;
    }
    glEnd();

    ++i;
  }
}
*/

void drawLineSegment(point endPt1, point endPt2)
{

	glBegin(GL_POINTS);								//Zeichenmodus setzten	
	glVertex2i(endPt1.x, endPt1.y);

	glEnd();	
}

void drawLine(point endPt1, point endPt2)
{

	drawLineSegment(endPt1,endPt2);
	glBegin(GL_LINES);
	glFlush();

	glVertex2i(endPt1.x, endPt1.y);	
	glFlush();

}

void buttonBoxFcn(GLint button, GLint action)
{
	if(button==action)
		exit(0);
	else
		exit(1);
}

void polyline(GLint button, GLint action, GLint xMouse, GLint yMouse) //Mouse callback prozedur
{
	static point endPt1, endPt2;
	static float x,y;
	struct point a;

	if(button == GLUT_RIGHT_BUTTON && action == GLUT_DOWN)
		{
			endPt1.x = xMouse;
			endPt1.y = winHeight - yMouse;

			cout<<endPt1.x<<"\n" ;
			cout<<endPt1.y<<"\n";

			a.x = endPt1.x ;
			a.y = endPt1.y;
			draw();

			drawLineSegment(endPt1, endPt2);
			speichern(a.x, a.y);
			glFlush();
			drawLine(endPt1, endPt2);

			glFlush();
			glFlush();

		}
	else 
		if(button == GLUT_LEFT_BUTTON && action == GLUT_DOWN)

			//draw();
			//draw_polygons();
			//draw_polygons();

			//float *g;
			//float *t;
			//g = &erste[0];
			//t = &erste[1];

			//glVertex2i(g,t);
			//glVertex2iv(erste);
		//	int point[] = {10,20};
		//	glVertex2iv(point);

			glEnd();	
	//bool bInAction = false;
			glFlush();							   //zeichen
}

void main(int argc, char**argv)
{

	glutInit(&argc, argv);                         //initialisierung der GLUT Bibliothek
	glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);   //Initialisierung des Bildschirms(Art des Zwischenspeichers, Farben)
	glutInitWindowPosition(100,100);			   //Positionierung des Fensters
	glutInitWindowSize(winWidth,winHeight);		   //Fenstergröße
	glutCreateWindow("Draw Interactive Polyline"); //Fenstertitel

	init();
	glutButtonBoxFunc(buttonBoxFcn);
	glutDisplayFunc(displayFcn);				   //Festlegen der Funktion die zum zeichen auf dem Bildschurm verwendet wird
	glutReshapeFunc(winReshapeFcn);
	glutMouseFunc(polyline);					   //Funktion die die Funktion "polyline" aufruft, wenn der Maus betätigt wurde

	glutMainLoop();
}

ich nehme an, dass deine "falsche" Ausgabe hierher kommt:

void draw()
{

    std::vector<point>::iterator i = punktliste.begin();

    for ( i=punktliste.begin(); i != punktliste.end(); ++i ){

        cout<<(int)i<<"\n";

    }
}

So kannst du die einzelnen Punkte natürlich nicht ausgeben lassen. punktliste enthält doch points, und ein point besteht aus zwei ints. Du kannst den point nicht einfach auf int casten, bzw, dann entsteht eben genau die Ausgabe, die du da bekommen hast. Du musst die einzelnen Elemente von i (x und y) ausgeben.

Noch was: es ist immer ein bisschen anstrengend, wenn man so ewig lange Listings durchschauen muss - begrenze doch bitte die Code-Ausschnitte auf die wesentlichen Teile.

Grüße

...das mit Konstruktor gibt mir andauernd ne Fehlermeldung ...

Ich vermute, dass das daran liegt, dass Du keinen "Copy-Konstruktor" definiert hast. Solange Du gar keinen Ctor definierst, legt der Compiler für Dich automatisch 3 Funktionen an: "Default-Ctor" (also einer ohne Argumente), Copy-Ctor (der aus einem übergebenen Objekt das eigene "füllt") und ein operator=() (der genauso arbeitet wie der CpyCtor).

(Einige) Diese(r) Operationen brauchst Du, wenn Du StdContainer (wie "vector") verwenden willst. Also:
- Entweder diese 3 selbst definieren (ist nicht wirklich schwierig)
- oder gar keinen.

Gruß,

Simon2.

error C2552: 'punkt' : non-aggregates cannot be initialized with initializer list

kennt das einer von euch ?

point punkt = {x,y};

nicht mehr.
Würde imho auch nicht mehr funktionieren sobald die struct Members hätte die private oder protected sind.

Gruß Spacelord

Also mit casten hat es nichts zu tun, dass int habe ich danach davorgestellt...

Das Casten ist dabei natürlich nicht der eigentliche Fehler. Trotzdem:

du machst sowas:

point p;
cout<< p;

du willst aber sowas:

point p;
cout<< p.x << "," << p.y;

Du versuchst, den point _direkt_ auszugeben. Egal, ob du noch castest oder nicht... es funktioniert nicht.

@Spacelord, wie kann ich es denn verhindern, dass er mir diese Fehlermeldung nicht mehr gibt, einfach diese Zeile mit

point punkt = {x,y};

entfernen ?

point punkt(x,y);

Compiling...
polgon.cpp
Linking...
polgon.obj : error LNK2001: unresolved external symbol "public: __thiscall point::point(void)" (??0point@@QAE@XZ)
Debug/Polygon.exe : fatal error LNK1120: 1 unresolved externals
Error executing link.exe.

struct point
{
public:
	int x,y;
	point();
	point(int _x, int _y) : x(_x), y(_y) {};

};

struct point
{
public:
    int x,y;
    point(int _x=0, int _y=0) : x(_x), y(_y) {};
};

Halt genau so wie ich es dir gestern Mittag schon in dem anderen Forum gepostetet habe.....

...
int x,y;
point() {};
point(int _x, int _y) : x(_x), y(_y) {};

sinnvoller wäre vielleicht aber auch statt

point() {};

sowas

point() {x = 0; y = 0;}

void draw()
{
	point p;  ??
	std::vector<point>::iterator i = punktliste.begin();

	for ( i=punktliste.begin(); i != punktliste.end(); ++i ){

		cout<<"wert   "<<p.x<<p.y<<"\n";
	}
}

das klappt aber nicht so, was mache ich denn hier falsch ? Ok, mein Konstruktor hat 2 Parameter ? vielleicht ist das mein Fehler, muss ich den hier mit zeigern arbeiten ?

Der point p ist unnötig, bei dir müsste es natürlich i.x << i.y sein.
Aber vorsicht, ich habe sowas in Erinnerung, dass man bei Iterators mit Zeigern arbeitet, also vielleciht muss es auch heißen i->x << i->y.
[edit]
Aus meiner Erinnerung... vielleicht sogar so: *i->x . Ich weiß es aber nicht mehr so genau.
[/edit]

Ansonsten... sowas hier geht auch:

void draw()
{
    for ( i = 0; i < punktliste.size(); i++ ){

        cout<< "wert   " << punktliste[i].x << punktliste[i].y << "\n";
    }
}

Sehe ich aber selten hier im Forum, weiß nicht, ob das verpönt ist und Nachteile hat - würde aber funktionieren.

....das mit glVertex und so müsste ich schon hinkriegen...

Sei mir nicht böse, aber zum momentanen Zeitpunkt habe ich Zweifel daran.

Gruß Spacelord

ich möchte euch nochmal was fragen, wenn ich die Polygone zeichnen möchte, bekomme ich nicht alle Linien gezeichnet, sonderen immer den darauf folgenden, ich habe folgendes gemacht einfach:

void zeichne()
{
	for(int i = 0;i<punktliste.size();i++)
	{
		cout<<"wert   "<<punktliste[i].x<<"   "<<punktliste[i].y<<"\n";
		glBegin(GL_LINES);
		glVertex2i(punktliste[i].x,punktliste[i].y);	
	}   
}

Ich möchte jetzt nun so vorgehen, dass ich noch einen struct definiere und die Linien in einen vector abspeichere und danach einfach durchlaufen lassen. Ich mein, findet Ihr es denn Effizient das so zu machen, denn ich möchte die Polygone abspeichern und laden können, und wenn ich 2 - 3 vectoren habe, ist das doch ein wenig kompliziert gemacht oder nicht ?

was meint Ihr ?