Grundlegende Fragen zu Zeigern

Kaladial

Moin

ich hab mel ein paar fragen zu zeigern, ich versteh sie derzeit einfach nicht und vielleicht könnt ihr mir das so erklären das ich da auch endlich net mehr wie nen depp aus der wäsche guck wenns um das thema geht

also kleines beispiel:

ich habe eine Klasse CPicture *
Dort sind einfach Bilddaten enthalten ein paar funktionen usw werte die man braucht (ist hier nur ein auszug):

class CPicture  {
protected:
	int rmode;
	CString name;
	int w;
	int h;
	unsigned char *cbnull;
	unsigned char *tcbnull;
	int picnr;
public:
	BOOL Transform8(CGrabber *grabber,unsigned char *dest);
	int ScaleDown(int si,int di,int x1,int y1,int x2,int y2,int x,int y,int f);

};

in meiner testfunktion gehe ich davon aus das ich schon ein bild aufgenommen hab und dieses nun an eine andere funktion übergeben will

doc->daten enthält also das ausgangs bild bzw die ausgangsbilder:

int BV_FixImagesCmd()  {
	CAVSCDoc *doc = (CAVSCDoc *)data;

        doc->daten->SetPicNr(1);
	CPicture *pic1 = doc->daten;
	doc->daten->SetPicNr(2);
	CPicture *pic2 = doc->daten;
	doc->daten->SetPicNr(3);
	CPicture *pic3 = doc->daten;
	doc->daten->SetPicNr(4);
	CPicture *pic4 = doc->daten;

	FixImages(&pic1, &pic2, &pic3, &pic4); //<--- hier weis ich nicht wie ich es schreiben soll
}

//hier möchte ich auf den inhalt der variablen zugreifen (also eigentlich als Speicheradresse)
BOOL FixImages(CPicture &pic1, CPicture &pic2, CPicture &pic3, CPicture &pic4)  {

	return TRUE;
}

Wie müsste der code denn nun richtig aussehn ?
also ich komm mit dem * und dem & nicht klar ich weis einfach nicht wie ich diese richtig einsetze

im endeffekt möchte ich eine kopie der bilder 1-4 in pic1 - pic4 anlegen und dann an meine funktion nur die speicheradressen übergeben auf diesen bildern arbeiten und wenn ich damit fertig bin hab ich in pic1-pic4 die bearbeiten bilder ohne groß etwas zurück zu geben

wie geht das?

mfg und thx für die hilfe
Kala

Th69

Von Zeiger nach Referenz: Dereferenzieren

FixImages(*pic1, *pic2, *pic3, *pic4);

Wenn du aber mit einer Kopie der Bilder arbeiten willst (und nicht auf den Originaldaten), dann mußt du in etwa so vorgehen:

doc->daten->SetPicNr(1);
CPicture pic1 = *doc->daten; // entspricht: CPicture pic1(*doc->daten)
// ... 

FixImages(pic1, pic2, pic3, pic4);

Dazu muß dein CPicture aber einen Kopierkonstruktor bereitstellen:

CPicture(const CPicture &other);

(und dort dann ein Deep-Copy durchführen)
Beachte dann aber auch: Regel der Großen Drei

Kaladial

also wenn ich das richtig verstehe:

CPicture pic1 //Erzeugt eine Leere Variable

= *doc->daten; //Kopiert den INHALT in diese Variable (durch den * ?)

FixImages(pic1, pic2, pic3, pic4); //Bei dieser Funktion übergebe ich dann also die Variablen direkt?

BOOL FixImages(CPicture &pic1, CPicture &pic2, CPicture &pic3, CPicture &pic4) {

// und weil ich hier & benutze, benutze ich nur die Referenz auf die Variablen?

Kann man das so sagen?
Sorry ich versteh nicht wann ich * und wann ich & benutzen soll...
Ich hab Programmierung gelernt und arbeite seit Jahren damit: lustigerweise hab ich mich immer um Zeiger drücken können ... es wurde mir halt nie richtig erklärt daher hier die Frage ... will endlich die Wissenslücke beseitigen

RHBaum

CPicture pic1 //Erzeugt eine Leere Variable

bissi vorsicht mit dem begriff "leer", das ist in c++ bisschen undefiniert ^^

jede instanciation einer klasse, egal ob aufm stack oder via new aufm Heap erzeugt eine funktionsfähige instanz ... mit allem membern und allen was dann noch gebraucht wird (vtable etc ... )

DIe konstruktoren sind quasi die init funktionen, die initialisierungslisten sind für initiale befüllung der member zuständig, bevor die konstruktoren ausgeführt werden. Uninitialisierte Member von POD (plain old data) Typen (int, char, alles mit * ....) nehmen irgendwelche Werte an, "irgendwelche" heisst in dem falle nicht definiert. Kann also so, oder mal so sein .... debug/release manchmal auch unterschiedlich.

Sorry ich versteh nicht wann ich * und wann ich & benutzen soll...

Zeiger und Referenz unterscheiden sich technisch eher wenig. Eher für den Anwender entstehen die Unterschiede.
Referenzen sind auch ein C++ sprachmittel.

Vorstellen kannst du dir eine referenz, als konstanter Zeiger deine Instanz, mit eingebauter dereferenzierungsfunktion.
C++ implementationsintern wird ne referenz auch nen zeiger sein ... wenn man davon ausgeht das c++ soweiso durch nen nen c compiler erzeugt wird/wurde, da gibtzs keine referenzen.

Den unterschied macht das "konstant".
D.h. für dich, das du das Ziel einer referenz nicht verändern kann, d.h. du musst beim erzeugen immer gleich das ziel angeben (in klassen braucht man dafür die initialisierungslisten)
Ne unitialisierte referenz wuerde irgendwohin zeigen und dadurch komplett "unbrauchbar"

Die regel für die Verwendung referenz vs. Zeiger ist relativ einfach geschrieben:
Referenzen wo du kannst, Zeiger wo du musst !

Zeiger nimmt man wenn:
du zeiger auf Null brauchst, also ungültigkeitswerte die du nicht durch vollständige Instanzen deiner klasse designen willst/kannst.
und wenn du das ziel auf der selben variable des Zeigers ändern willst, musst ...

Ciao ...

theta

Nur so, weils noch niemand erwähnt hat: Du hast im falschen Unterforum gepostet, hier ist C++/CLI, das ist eine .NET Sprache und nicht ISO C++.