Falsche Variablenwerte bei abgeleiteter Klasse

[Francis123]

ich hab eine wrapper klasse für windows fenster erstellt, davon eine abgeleitete klasse für eine scrollbar. das problem ist, dass trotz richtiger initialisierung immer irgendwelche falschen werte ausgegeben werden.
die abgeleitete klasse heist ScrollBar und ist von WinWrap abgeleitet. der einzige konstruktor enthält zum beispiel das:

this->scrollRange=1;

woanders im programm rufe ich dann erstmal das auf:

WinWrap* scroller=mainWindow.searchChild((HWND)lParam);
	cons<<((ScrollBar*)scroller)->scrollRange<<"\n";

statt 1 auszugeben wird irgendein gewaltiger int wert ausgegeben. wenn ich im konstruktor das direkt nach der zuweisung ausgebe, ist es richtig.
mainWindow ist vom typ WinWrap und searchChild sieht so aus:

WinWrap* WinWrap::searchChild(HWND hWnd)
{
	WinWrap* tmp;
	for(int i=0; i<children.size();i++)
		if((tmp=children.at(i).searchChild(hWnd)))
			return tmp;
		else if(children.at(i).hWnd==hWnd)
			return &children.at(i);
	return NULL;
}

children ist ein vector für WinWrap objekte.
es wird nicht null zurückgegeben, das hab ich geprüft.
also hab ich vieleicht bei der klassenvererbung irgendwas falsch verstanden oder was zum teufel läuft da wieder nicht?

[Sone]

Zeig.Code.

[Francis123]

rede normal mit mir oder lass es gleich sein. welchen teil der über 1000 zeilen soll ich hier posten damit sich überhaupt irgendwer das anschaut? ich bin sowieso schon fertig mit den nerven wegen dem gottverdammten c++ der immer probleme macht.
hier:

//main.cpp

LRESULT CALLBACK WndProc01(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam);

WinWrap mainWindow;
HHOOK hHook;

int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
                     PSTR szCmdLine, int iCmdShow)
{	
   mainWindow=WinWrap(
	NULL,
	"myWindowClass",
	"mainWindow",
	WS_OVERLAPPEDWINDOW,
	100,100,300,300,
	NULL,
	NULL,
	hInstance
		);
   mainWindow.i_register(WndProc01);
   mainWindow.createWindow();
   mainWindow.showWindow(1);

	mainWindow.msgLoop();

	return 0;
}

//WinWrap.h inklusive ScrollBar klasse

#ifndef _WINWRAPPER_H_
#define _WINWRAPPER_H_

#include <Windows.h>
#include <string>
#include <vector>
#include "Console.h"

using namespace std;

extern const int BUTTON_WIDTH_01;
extern const int BUTTON_HEIGHT_01;
extern cout cons;
class WinWrap
{

public:	

//*************

  WinWrap* parent;

  DWORD dwExStyle;
  LPCTSTR lpClassName;
  LPCTSTR lpWindowName;
  DWORD dwStyle;

  LPVOID lpParam;

	static const int ALIGN_RIGHT=-1;
	static const int ALIGN_LEFT=-2;
	static const int ALIGN_TOP=-2;
	static const int ALIGN_BOTTOM=-1;
	static const int ALIGN_CENTER=0;

	int align_x;
	int align_y;

//****
	  int x;
	  int y;
	  int nWidth;
	  int nHeight;

	  int shift_x;
	  int shift_y;

	  HINSTANCE hInstance;

	  HWND hWndParent;

      HMENU hMenu;

	  vector<WinWrap> children; 

//***********

	//window handle
	HWND hWnd;	
    MSG msg;	
    WNDCLASSEX wcls;

	//messageloop laufen lassen?
	bool b_msgLoop;		

	//messages annehmen?
	bool b_msgAccept; 

	WinWrap(
  DWORD dwExStyle,
  LPCTSTR lpClassName,
  LPCTSTR lpWindowName,
  DWORD dwStyle,
  int x,
  int y,
  int nWidth,
  int nHeight,
  HWND hWndParent=NULL,
  HMENU hMenu=NULL,
  HINSTANCE hInstance=NULL,
  LPVOID lpParam=NULL,
  BOOL start=FALSE
  );

	WinWrap(){};

	//Button
WinWrap(
		HWND hWndParent,
		LPCSTR lpWindowName,
		HMENU hMenu,
		int x,
		int y,
		int align_x= ALIGN_LEFT, int align_y=ALIGN_TOP, 
		int w=BUTTON_WIDTH_01,
		int h=BUTTON_HEIGHT_01,
		DWORD dwStyle=WS_CHILD | BS_PUSHBUTTON,
		LPCSTR lpClassName="button"
		);

	//alle variablen initialisieren
	int init(
  DWORD dwExStyle,
  LPCTSTR lpClassName,
  LPCTSTR lpWindowName,
  DWORD dwStyle,
  int x,
  int y,
  int nWidth,
  int nHeight,
  HWND hWndParent=NULL,
  HMENU hMenu=NULL,
  HINSTANCE hInstance=NULL,
  LPVOID lpParam=NULL,
  BOOL start=false
	);

	WinWrap* searchChild(LPTSTR lpWindowName);
	WinWrap* searchChild(HMENU hMenu);
	WinWrap* searchChild(HWND hWnd);

	int start(int iCmdShow=1, WNDPROC proc=NULL);

	int i_register(WNDPROC proc);

	int msgLoop();

	//text, id, x, y, dword style, alignx, aligny, width, height
	int addChild(LPCSTR text, int id, int x, int y,DWORD style= WS_CHILD|WS_VISIBLE|BS_PUSHBUTTON, int align_x=ALIGN_LEFT, int align_y=ALIGN_TOP, int width=BUTTON_WIDTH_01, int height=BUTTON_HEIGHT_01); 

	WinWrap* addChild(WinWrap& child);

	int updateChildren();

	int update(const WinWrap* parent);

	int createWindow();

	int showWindow(int iCmdShow){	return ShowWindow(hWnd, iCmdShow);	};

	//**** getters & setters 

	int getWidth(){return nWidth;}
	int getHeight(){return nHeight;}

	int getShiftX()const {return shift_x;}
	int getShiftY()const {return shift_y;}

	int getX()const{return x;};
	int getY()const{return y;};

	void setWidth(int n){nWidth=n;}
	void setHeight(int n){nHeight=n;}

	void setX(int n){x=n;}
	void setY(int n){y=n;}

	void setShiftX(int n) {shift_x=n;}
	void setShiftY(int n){shift_y=n;}

	int getXifChild() const {return parent?getX()+getShiftX():0;}

	int getYifChild() const {return parent?getY()+getShiftY():0;}

	WinWrap* getLastChild() {	  return children.size()>0?&children.at(children.size()-1):NULL;	}
		//Letztes Child aus dem Vector zurückgeben oder NULL wenn leer
};

class ScrollBar:public WinWrap
{

public:
	int scrollRange;
	int scrollPos;
	int scrollStep;

	int max_w;
	int max_h;

	LPCSTR asdf;

	ScrollBar(DWORD orientation, int x, int y, int w, int h, HWND hWndParent, HINSTANCE hInstance );	

	int getScrollRange ()const{return scrollRange;}
	int getScrollPos() const {return scrollPos;}
	int getScrollStep() const {scrollStep;}

	void setScrollRange(int n) {scrollRange=n; if(hWnd){cons<<"setScrollRange:"<<SetScrollRange(hWnd,SB_CTL,0,n,true)<<"|"<<GetLastError()<<"\n";}}
	void setScrollPos(int n);
	void setScrollStep(int n){this->scrollStep=n;}

	int update(const WinWrap* parent);

	LRESULT defaultProc(DWORD wParam);

	int createWindow();

	int init(
	  DWORD dwExStyle,
	  LPCTSTR lpClassName,
	  LPCTSTR lpWindowName,
	  DWORD dwStyle,
	  int x,
	  int y,
	  int nWidth,
	  int nHeight,
	  HWND hWndParent=NULL,
	  HMENU hMenu=NULL,
	  HINSTANCE hInstance=NULL,
	  LPVOID lpParam=NULL,
	   BOOL start=false,
	  int scrollRange=5,
	  int scrollStep=1,
	  int scrollPos=1
	);

};

WNDCLASSEX getDefaultWCLS(WNDPROC WndProc, HINSTANCE hInst, LPCSTR lpszAppName);

#endif

//WinWrap.cpp
#include <Windows.h>
#include <string>
#include "WinWrap.h"
#include "Console.h"
#include <vector>
#include "Global.h"

using namespace std;

extern cout cons;
extern const int BUTTON_WIDTH_01 ;
extern const int BUTTON_HEIGHT_01 ;
extern WinWrap mainWindow;
LRESULT CALLBACK WndProc01(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam);		//WndProc.cpp

 WinWrap::WinWrap(
  DWORD dwExStyle,
  LPCTSTR lpClassName,
  LPCTSTR lpWindowName,
  DWORD dwStyle,
  int x,
  int y,
  int nWidth,
  int nHeight,
  HWND hWndParent,
  HMENU hMenu,
  HINSTANCE hInstance,
  LPVOID lpParam,
  BOOL start
  )
	{
		init(dwExStyle, lpClassName, lpWindowName, dwStyle, x,y,nWidth, nHeight, hWndParent, hMenu, hInstance);
		parent=NULL;
		cons<<"Window "<<lpWindowName<<" created\n";
	}

 WinWrap::WinWrap(
		HWND hWndParent,
		LPCSTR lpWindowName,
		HMENU hMenu,
		int x,
		int y,
		int align_x, int align_y, 
		int nWidth,
		int nHeight,
		DWORD dwStyle,
		LPCSTR lpClassName
		)
 {
	init(NULL, lpClassName, lpWindowName, dwStyle, x,y, nWidth, nHeight, hWndParent, hMenu, NULL,NULL);
 }

 //*************initialisierung*********
 int WinWrap::init(
   DWORD dwExStyle,
  LPCTSTR lpClassName,
  LPCTSTR lpWindowName,
  DWORD dwStyle,
  int x,
  int y,
  int nWidth,
  int nHeight,
  HWND hWndParent,
  HMENU hMenu,
  HINSTANCE hInstance,
  LPVOID lpParam,
  BOOL start)
 {
	 	this->dwExStyle=dwExStyle;
		this->lpClassName=lpClassName;
		this->lpWindowName=lpWindowName;
		this->dwStyle=dwStyle;
		this->shift_x=x;		//x wird nur dynamisch vom programm geändert
		this->shift_y=y;
		this->nWidth=nWidth;
		this->nHeight=nHeight;
		this->hWndParent=hWndParent;
		this->hMenu=hMenu;
		this->hInstance=hInstance;
		this->lpParam=lpParam;

		this->x=0;
		this->y=0;

		this->b_msgAccept=true;
		this->b_msgLoop=true;

			if(start)
			this->start();

			return 1;
 }
 //*********************

int WinWrap::i_register(WNDPROC proc)
{
	cons<<"Registrating window "<<lpWindowName<<"\n";
		this->wcls=::getDefaultWCLS(proc, this->hInstance, this->lpClassName);
	    if(RegisterClassEx(&(this->wcls)))		//muss vor createwindowex passieren
			return 0;
		else
		return 1;
}

WinWrap* WinWrap::searchChild(LPTSTR lpWindowName)
{
	for(int i=0; i<children.size();i++)
		if(wcscmp((WCHAR*)children.at(i).lpWindowName, (WCHAR*)lpWindowName))
			return &children.at(i);

	return NULL;
}

WinWrap* WinWrap::searchChild(HWND hWnd)
{
	WinWrap* tmp;
	for(int i=0; i<children.size();i++)
		if((tmp=children.at(i).searchChild(hWnd)))
			return tmp;
		else if(children.at(i).hWnd==hWnd)
			return &children.at(i);
	return NULL;
}

WinWrap* WinWrap::searchChild(HMENU hMenu)
{
	for(int i=0; i<children.size(); i++)
		if(children.at(i).hMenu==hMenu)
			return &children.at(i);
	return NULL;
}

int WinWrap::addChild(LPCSTR text,int id,  int x, int y,DWORD style,int align_x, int align_y, int width, int height)
{
	WinWrap Button=WinWrap(NULL, "button", text, style, x,y,width,height, hWnd, (HMENU)id, hInstance, NULL,0 );
	Button.align_x=align_x;
	Button.align_y=align_y;

	Button.start(1, 0);
	children.push_back(Button);
	updateChildren();

	return 0;
}

WinWrap* WinWrap::addChild(WinWrap& child)
{
	cons<<"addChild("<<child.lpClassName<<"/"<<child.lpWindowName<<")\n";
	child.parent=this;
	child.createWindow();
	child.showWindow(1);
	WinWrap child_2(child);
	children.push_back(child_2);
	cons<<"&child: "<<&child_2<<"\n";
	return &children.at(children.size()-1);
}

int WinWrap::updateChildren()
{
	cons<<"*********updating children of "<<lpWindowName<<" *********\n";
	cons<<"this: "<<this<<"\n";
	cons<<"children: "<<children.size()<<"\n";
	for(int i=0; i<children.size();i++)
	{		
		children.at(i).update(this);
		children.at(i).updateChildren();
	}
	cons<<"***************************************\n";
	return 0;
	}

	int WinWrap::update( const WinWrap* p)
	{
		cons<<"------------------updating "<<lpWindowName<<"------------------\n";
		RECT parent;

		if(!GetClientRect(p->hWnd, &parent))
		{
			cons<<"HWND:"<<p->hWnd<<"\n";
			cons<<"Error:"<<GetLastError()<<"\n";
			return 9;
		}

	cons<<"ClientArea: "<<parent.left<<"|"<<parent.top<<"/"<<parent.right<<"|"<<parent.bottom<<"::: width/height: "<<getRectWidth(&parent)<<"/"<<getRectHeight(&parent)<<"\n";

		int x,y;

			if(align_x== ALIGN_RIGHT)
				setX(getRectWidth(&parent)-getWidth()+p->getXifChild());
			else if(align_x==ALIGN_CENTER)
				setX((getRectWidth(&parent)/2)-(getWidth()/2)+p->getXifChild());
			else
				setX(p->getXifChild());

			if(align_y==ALIGN_BOTTOM)
				setY(getRectHeight(&parent)-getHeight()+p->getYifChild());
			else if(align_y== ALIGN_CENTER)
				setY((getRectHeight(&parent)/2)-(getHeight()/2)+(p->getYifChild()));
			else
				setY(p->getYifChild());

			cons<<"Updating finished.\n";
			cons<<"setWindowPos:"<<
			SetWindowPos(hWnd, 0, getX()+getShiftX(),getY()+getShiftY(), getWidth(), getHeight(), NULL)
			<<"\n";
			cons<<"x= "<<getX()<<" | y = "<<getY()<<"\n";
				cons<<"------------------------------------\n";
			return 1;
	}

	int WinWrap::createWindow()
	{
		if(!(this->hWnd=CreateWindowEx(dwExStyle, lpClassName, lpWindowName, dwStyle, shift_y, shift_y, nWidth, nHeight, hWndParent, hMenu, hInstance, lpParam)))
			return 0;
		return 1;
	}

BOOL WinWrap::start(int iCmdShow, WNDPROC proc)
{

if(proc)
	i_register(proc);

if(!(this->hWnd=CreateWindowEx(dwExStyle, lpClassName, lpWindowName, dwStyle, x, y, nWidth, nHeight, hWndParent, hMenu, hInstance, lpParam)))
		return 421;
else
	cons<<"Starting window "<<this->lpWindowName<<": "<<GetLastError()<<"\n";

     ShowWindow(hWnd, iCmdShow);			//http://msdn.microsoft.com/en-us/library/windows/desktop/ms633548%28v=vs.85%29.aspx
	 UpdateWindow(hWnd);

	 return 1;
}

int WinWrap::msgLoop()
{
	while (this->b_msgLoop && GetMessage(&msg, NULL, 0, 0) > 0)		//http://msdn.microsoft.com/en-us/library/windows/desktop/ms644936%28v=vs.85%29.aspx
    {
		if(this->b_msgAccept)
		{
        TranslateMessage(&msg);
        DispatchMessage(&msg);
		}
		else
			Sleep(50);
	}
	return 1;
}

::WNDCLASSEX getDefaultWCLS(WNDPROC WndProc, HINSTANCE hInst, LPCSTR lpszAppName)
{
	WNDCLASSEX wc={0};

	wc.hInstance=hInst;
	wc.cbSize        =  sizeof(WNDCLASSEX);
    wc.style         =  CS_HREDRAW | CS_VREDRAW;
    wc.lpfnWndProc   =  WndProc;
    wc.cbClsExtra    =  0;
    wc.cbWndExtra    =  0;
    wc.hCursor       =  LoadCursor(NULL,IDC_ARROW);
    wc.hIcon         =  LoadIcon(NULL, IDI_APPLICATION);
    wc.hbrBackground =  (HBRUSH)GetStockObject(WHITE_BRUSH);
    wc.lpszClassName =  lpszAppName;
	//wc.lpszMenuName =	MAKEINTRESOURCE(ID_MENU_01);
	//wc.lpszMenuName	=	lpszAppName;
	wc.hIconSm       =  LoadIcon(NULL, IDI_APPLICATION);

	return wc;
}

//ScrollBar.cpp
#include <Windows.h>
#include <string>
#include "WinWrap.h"
#include "Console.h"
#include <vector>
#include "Global.h"

extern cout cons;

ScrollBar::ScrollBar(DWORD orientation, int x, int y, int w, int h, HWND hWndParent, HINSTANCE hInstance )
{
	init(NULL, "SCROLLBAR", "default", orientation|WS_CHILD|WS_VISIBLE, x,y,w,h,hWndParent, NULL, hInstance, NULL);
	this->scrollStep=1;
	cons<<"ScrollStep after setting to 1: "<<this->scrollStep<<"\n";
	cons<<"Creating Scrollbar\n";

}

	int ScrollBar::update(const WinWrap* parent)
	{
		WinWrap::update(parent);
	}

	LRESULT ScrollBar::defaultProc(DWORD wParam)
	{
		cons<<"Calling defaultProc. LOWORD(wParam)="<<LOWORD(wParam)<<"\n";
			cons<<"ScrollStep: "<<scrollStep<<"\n";
		switch(LOWORD(wParam))
			{
		     case SB_TOP:
                        setScrollPos(0);
                        break;

                case SB_LINEUP:
                        if (scrollPos > 0)
                          setScrollPos(scrollPos-1);
                        break;

                case SB_THUMBPOSITION:
                        setScrollPos(HIWORD(wParam));
                        break;

                case SB_THUMBTRACK:

                        break;

                case SB_LINEDOWN:
                        if (scrollPos < scrollRange)
                                setScrollPos(scrollPos+1);
                        break;

                case SB_BOTTOM:
                        setScrollPos(scrollRange);
                        break;

				case SB_PAGELEFT:		//klick in scrollbar shaft
						cons<<"scrollStep:"<<scrollStep<<"\n";
						setScrollPos(getScrollPos()-scrollStep);
						break;

				case SB_PAGERIGHT:
						setScrollPos(getScrollPos()+scrollStep);
						break;

                case SB_ENDSCROLL:
                        break;
		}
		return 0;
	}

	void ScrollBar::setScrollPos(int n)
	{
		cons<<"setting scrollPos to "<<n<<"\n";
		if(n<0)
			scrollPos=0;
		else if(n>scrollRange)
			scrollPos=scrollRange;
		else
			scrollPos=n;

		cons<<"scrollPos="<<scrollPos<<"\n";
		if(hWnd)
			{
			cons<<"scrollRange:"<<getScrollRange()<<"\n";
			cons<<"return of SetScrollPos:"<<SetScrollPos(hWnd, SB_CTL, getScrollPos(), TRUE)<<"\n";
			cons<<"error:"<<GetLastError()<<"\n";
			}
		else
			cons<<"HWND==NULL\n";
	}

int ScrollBar::init(
  DWORD dwExStyle,
  LPCTSTR lpClassName,
  LPCTSTR lpWindowName,
  DWORD dwStyle,
  int x,
  int y,
  int nWidth,
  int nHeight,
  HWND hWndParent,
  HMENU hMenu,
  HINSTANCE hInstance,
  LPVOID lpParam,
  BOOL start,
  int scrollRange,
  int scrollStep,
  int scrollPos
	)
{
	WinWrap::init(NULL, lpClassName, lpWindowName, dwStyle, x,y, nWidth, nHeight, hWndParent, hMenu,hInstance,NULL,start);
	setScrollRange(scrollRange);
	setScrollStep(scrollStep);
	setScrollPos(scrollPos);

	this->max_w=-1;
	this->max_h=-1;

		cons<<"ScrollStep after setting to 1: "<<this->scrollStep<<"\n";
	return 1;
}

WndProc.cpp
#include <Windows.h>
#include <string>
#include <stdio.h>
#include "resource.h"
#include "WinWrap.h"
#include "Global.h"

using namespace std;
extern cout cons;

	typedef BOOL (*UninstallHook)(void);
	extern UninstallHook UninstHook(0);
	extern WinWrap mainWindow;

	HWND hWndBar;

LRESULT CALLBACK WndProc01(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
		HDC hdc;
		PAINTSTRUCT ps;
		RECT rect;

		static const WCHAR* text={L"Dies ist ein \nverdammter test text \num das winapi\n zu testen...äöü"};
		static int cxChar, cyChar;

		HWND hWndScroller;
		SCROLLINFO si;
		int CurPos;
		char strPosition[20];

		hWndScroller=GetDlgItem(hWnd, IDC_SCROLLER);

		switch(msg)
		{

		case WM_INITDIALOG:
			cons<<"WM_INITDIALOG| msg = "<<msg<<" | wParam = "<<(char)wParam<<" | lParam = "<<lParam<<"\n";
			break;

		case WM_HSCROLL:		//lParam==HWND !!
		case WM_VSCROLL:
			{
				cons<<"WM_HSCROLL oder WM_HSCROLL\n";
			WinWrap* scroller=mainWindow.searchChild((HWND)lParam);
			if(!scroller)
				break;
			cons<<"????????___"<<((ScrollBar*)scroller)->asdf<<"\n";		
			cons<<"????????___"<<((ScrollBar*)scroller)->scrollRange<<"\n";		

			((ScrollBar*)scroller)->defaultProc(wParam);

					  sprintf(strPosition, "%d", CurPos);
			     SetDlgItemText(hWnd, IDC_LABEL, strPosition);
			return 0;
			}
		case WM_COMMAND:

			cons<<"WM_COMMAND| msg = "<<msg<<" | wParam = "<<(char)wParam<<" | lParam = "<<lParam<<"\n";
			switch(LOWORD(wParam))
			{

			}

			return 0;
		case WM_KEYDOWN:	
			cons<<"WM_KEYDOWN| msg = "<<msg<<" | wParam = "<<(char)wParam<<" | lParam = "<<lParam<<"\n";
			DialogBox(mainWindow.hInstance, MAKEINTRESOURCE(IDD_CONTROLS_DLG), NULL,(DLGPROC)WndProc01);
			return 0;

		case WM_MOVE:

			RECT r_move;
			GetWindowRect(hWnd, &r_move);
			mainWindow.setX(LOWORD(lParam));
			mainWindow.setY(HIWORD(lParam));

			return 0;

		case WM_SIZE:
			//cons<<"WM_SIZING| msg = "<<msg<<" | wParam = "<<(char)wParam<<" | lParam = "<<lParam<<"\n";
			RECT r;
			RECT c;
			GetClientRect(hWnd,&c);
			GetWindowRect(hWnd, &r);
			mainWindow.nWidth=r.right-r.left;
			mainWindow.nHeight=r.bottom-r.top;
			mainWindow.updateChildren();

			//SetWindowPos(hWndBar, NULL, 0,0, getRectWidth(&c), 20,NULL);

			return 0;

		case WM_CREATE:
			{
			cons<<"WM_CREATE | msg = "<<msg<<" | wParam = "<<(char)wParam<<" | lParam = "<<lParam<<"\n";

			//****SCROLLBAR EXPERIMENTING**
			//****

			TEXTMETRIC tm;
			hdc=GetDC(hWnd);

			GetTextMetrics(hdc, &tm);
			cxChar=tm.tmAveCharWidth;
			cyChar=tm.tmHeight;

			ReleaseDC(hWnd, hdc);
//*************************ADDING ELEMENTS*****************

	   SetScrollRange(hWndBar,SB_CTL, 0, 100, false); 

			//*********
				ScrollBar scrollBar(SBS_HORZ, 0, 0, 200,20, hWnd, mainWindow.hInstance);
				if(!mainWindow.addChild(scrollBar))
					cons<<"addind scrollbar failed\n";
				scrollBar.setScrollRange(100);

				WinWrap* tmpWin;

				WinWrap window_template=WinWrap(
				NULL,
				"button",
				"myControl",
				dwGroupBoxStyle,			
				MARGIN_DEFAULT,		//x
				-MARGIN_DEFAULT,		//y
				2*BUTTON_WIDTH_01+3*MARGIN_DEFAULT  ,		//width 
				2*BUTTON_HEIGHT_01,		//height
				hWnd,		//parent
				(HMENU)0);
				window_template.align_x=WinWrap::ALIGN_LEFT;
				window_template.align_y=WinWrap::ALIGN_BOTTOM;

				tmpWin=mainWindow.addChild(window_template);

				window_template.setY(MARGIN_DEFAULT_02);
				window_template.setWidth(BUTTON_WIDTH_01);
				window_template.setHeight(BUTTON_HEIGHT_01);
				window_template.dwStyle=dwButtonStyle;
				window_template.lpWindowName="Add";
				window_template.hMenu=(HMENU)ID_BUTTON_ADD;
				window_template.align_x=WinWrap::ALIGN_CENTER;
				window_template.align_y=WinWrap::ALIGN_CENTER;
				window_template.setShiftX(window_template.getWidth()/2+MARGIN_DEFAULT/2);
				window_template.setShiftY(4);

				tmpWin->addChild(window_template);

				window_template.lpWindowName="Edit";
				window_template.hMenu=(HMENU)ID_BUTTON_EDIT;	
				window_template.setShiftX(-window_template.getWidth()/2-MARGIN_DEFAULT/2);

				tmpWin->addChild(window_template);

//**************************/ADDING ELEMENTS*****************

			return 0;
			}

		case WM_PAINT:

			hdc=BeginPaint(hWnd, &ps);
			GetClientRect(hWnd, &rect);

			//TextOut(hdc, 0,0, (LPCSTR)text, wcslen(text)*2);
			//DrawText(hdc, TEXT("text"), -1, &rect, DT_SINGLELINE );
			EndPaint(hWnd, &ps);
			return 0;
		case WM_DESTROY:
			UninstHook();
			PostQuitMessage(0);
			return 0;

		}

		return DefWindowProc(hWnd, msg, wParam, lParam);
};

[Dobi]

Versuch mal, deinen Code auf ein Minimalbeispiel zu reduzieren (http://www.c-plusplus.net/forum/304133). Eventuell findest du das Problem, dass du mit dem bösen C++ hast, dann schon selbst.

[Francis123]

kann man überhaupt in einen Vector für eine klasse objekte einer abgeleiteten klasse speichern? die funktion der abgeleiteten klasse wird nach dem cast zumindest aufgerufen, aber die verfluchten variablen haben falsche werte.

[Der Tobi]

der einzige konstruktor enthält zum beispiel das

ScrollBar::ScrollBar(DWORD orientation, int x, int y, int w, int h, HWND hWndParent, HINSTANCE hInstance )
{
    init(NULL, "SCROLLBAR", "default", orientation|WS_CHILD|WS_VISIBLE, x,y,w,h,hWndParent, NULL, hInstance, NULL);
    this->scrollStep=1;
    cons<<"ScrollStep after setting to 1: "<<this->scrollStep<<"\n";
    cons<<"Creating Scrollbar\n";

}

Wo?

Du änderst diesen Wert nur in der init() Methode und die rufst du hier

case WM_VSCROLL:
            {
                cons<<"WM_HSCROLL oder WM_HSCROLL\n";
            WinWrap* scroller=mainWindow.searchChild((HWND)lParam);
            if(!scroller)
                break;
            cons<<"????????___"<<((ScrollBar*)scroller)->asdf<<"\n";        
            cons<<"????????___"<<((ScrollBar*)scroller)->scrollRange<<"\n";     

            ((ScrollBar*)scroller)->defaultProc(wParam);

                      sprintf(strPosition, "%d", CurPos);
                 SetDlgItemText(hWnd, IDC_LABEL, strPosition);
            return 0;
            }

doch gar nicht auf
Oder stammt der Code, den du gepostet hast nicht von dieser Stelle?

[Francis123]

Der Tobi schrieb:

der einzige konstruktor enthält zum beispiel das

ScrollBar::ScrollBar(DWORD orientation, int x, int y, int w, int h, HWND hWndParent, HINSTANCE hInstance )
{
    init(NULL, "SCROLLBAR", "default", orientation|WS_CHILD|WS_VISIBLE, x,y,w,h,hWndParent, NULL, hInstance, NULL);
    this->scrollStep=1;
    cons<<"ScrollStep after setting to 1: "<<this->scrollStep<<"\n";
    cons<<"Creating Scrollbar\n";
 
}

Wo?

Du änderst diesen Wert nur in der init() Methode und die rufst du hier

case WM_VSCROLL:
            {
                cons<<"WM_HSCROLL oder WM_HSCROLL\n";
            WinWrap* scroller=mainWindow.searchChild((HWND)lParam);
            if(!scroller)
                break;
            cons<<"????????___"<<((ScrollBar*)scroller)->asdf<<"\n";        
            cons<<"????????___"<<((ScrollBar*)scroller)->scrollRange<<"\n";     
 
            ((ScrollBar*)scroller)->defaultProc(wParam);
                
 
                      sprintf(strPosition, "%d", CurPos);
                 SetDlgItemText(hWnd, IDC_LABEL, strPosition);
            return 0;
            }

doch gar nicht auf
Oder stammt der Code, den du gepostet hast nicht von dieser Stelle?

das im startpost ist abgeändert als beispiel, aber jede variable der abgeleiteten klasse wird nach dem scheiß cast falsch ausgegeben.

[Der Tobi]

Deine searchChild-Methode gibt ein WinWrap* zurück. Du weist diesen Rückgabewert einen WinWrap* zurück. Wo zur Hölle sollen die Informationen für den Compiler herkommen, dass du eigentlich ein ScrollBar* haben wolltest? Der fügt die bei dem Cast doch nicht einfach so dazu. Allgemein deuten Casts an, dass du nie ein richtig gutes C++ Buch gelesen hast, denn dort wäre dir die Unnötigkeit von Casts erläutert worden.

tl;dr: WinWrap* scroller wird ein WinWrap* zugewiesen und du versuchst mit dem Cast einfach nur Compilererrors zu unterdrücken.

PS: Mach dir um Sone keine Gedanken, er will nur Aufmerksamkeit.

[Francis123]

wenn c++ primer kein gutes buch ist dann nein, ich hab nie ein gutes c++ buch gelesen.
ich dachte ein pointer wär immer gleich, egal ob es ein int pointer ist oder ein pointer zu irgendeinem objekt, ist das nicht immer nur ein int wert? oder liegt das am vector objekt wo das zeug gespeichert ist?

ich hab hier die sache an nem beispiel getestet:

testclass t01=testclass();
		testclass02 t02=testclass02();

		testclass* pt01=&t02;

		cout<<"t01: a="<<t01.a<<endl;
		cout<<"t02: a="<<t02.a<<" b="<<t02.b<<endl;

		cout<<"pointers...."<<endl;

		cout<<((testclass02*)pt01)->b<<endl;

und es funktioniert so mit cast. testclass hat ne variable namens a, testclass02 eine namens b. dem pointer auf testclass wird aber die adresse vom testclass02 objekt zugewiesen, und dann durch nen cast die variable b die nur in testclass02 vorhanden ist ausgegeben. die ausgabe ist immer richtig.

[Sone]

Nikolai schrieb:

ch dachte ein pointer wär immer gleich, egal ob es ein int pointer ist oder ein pointer zu irgendeinem objekt, ist das nicht immer nur ein int wert?

Na klar. Ein Pointer ist nur ein ganz normaler integraler Basisdatentyp, die Größe ist meistens 4 oder 8 Byte.
Grob betrachtet können Pointer eben nur eine Adresse speichern.

Aber diese "Gleichheit" hört schon da auf, wo man die Pointer benutzt.

Nikolai schrieb:

oder liegt das am vector objekt wo das zeug gespeichert ist?

Wie meinst du das? std::vector selbst kann natürlich nicht beeinflussen, wo das Array liegt, den der Standardallokator soll laut Standard ausdrücklich den ganz normalen new -Operator verwenden.

Nikolai schrieb:

ich hab hier die sache an nem beispiel getestet:

testclass t01=testclass();
		testclass02 t02=testclass02();

		testclass* pt01=&t02;
		
		cout<<"t01: a="<<t01.a<<endl;
		cout<<"t02: a="<<t02.a<<" b="<<t02.b<<endl;
	
		cout<<"pointers...."<<endl;

		cout<<((testclass02*)pt01)->b<<endl;

und es funktioniert so mit cast. testclass hat ne variable namens a, testclass02 eine namens b. dem pointer auf testclass wird aber die adresse vom testclass02 objekt zugewiesen, und dann durch nen cast die variable b die nur in testclass02 vorhanden ist ausgegeben. die ausgabe ist immer richtig.

Na ob das mal nicht UB ist...
Aber klar, der Offset der Member ist in beiden Klassen natürlich gleich, dann funktioniert es (kannst es ja auch nochmal mit offsetof testen).

[Francis123]

also ich hab jetzt in der winwrap klase den typ den std::vector speichert in pointer geändert, dadurch funktioniert auch der cast in einen pointer zu einem objekt der abgeleiteten klasse, und die verfluchte scrollbar geht jetzt auch endlich. so wie das voran geht wird bei mir nie ein programm fertig außer konsolenanwendung mit par dialogen.

[Th69]

Hallo Nikolai,

vector<WinWrap> children;

speichert nur die Informationen der Basisklasse - das Stichwort dazu lautet "Slicing", s. z.B. http://en.wikipedia.org/wiki/Object_slicing

Verwende aber anstatt einem Zeiger besser einen Shared-Pointer z.B. "unique_ptr" oder "shared_ptr" aus C++11 bzw. boost:

vector<unique_ptr<WinWrap>> children;

[Sone]

Wenn Boost, wieso dann nicht gleich Pointer-Container?

[Th69]

Ich mag diese Pointer Container Library nicht, weil sie intern immer noch "void " anstatt "T" verwendet...
Und zum anderen, weil ich das Konzept sowie die Benennung "ptr_vector", "ptr_map", ... total bescheuert finde.
Aber kann ja jeder halten, wie er will...