Richtige Deklaration und Zugriff auf ein dynamisches Array

duckler

Hallo Leute ,

ich habe ein Programm zum berechnen des realen und des imaginären Teils einer komplexen Zahl geschrieben.
Um den (gestern von euch >Danke Dweb<) erklärten Kopierkonstruktor zu verstehen habe ich natürlich damit herumgespielt. Das ganze hat auch schön funktioniert bis ich auf die Idee kam ein dynamisches charArray zu deklarieren. Nach einigem rumprobieren hat es dann zwar geklappt aber nur die Lesevariante also

char*charArray;

wenn ich das anders versuche um den Inhalt meines Arrays später in einer Funktion

arra() const

zu ändern bekomme ich die Fehlermeldung

error C2166: L-Wert gibt ein konstantes Objekt an

.

Ich versuch nun schon seit 2 Stunden da durchzusteigen aber es klappt nicht.
Könntet Ihr mir da wieder helfen?

Hier mein kleines geändertes Prroggie mit dem dynamischen Array:[u]

Die Klasse:

#include <iostream.h>
#include <stdio.h>
#include <string.h>

class complex
{
	private:

		float	*re, *im;
		int		iNoPointer;
		char	*charArray;

	public:

		complex(float r, float i);
		complex(const complex& CopyConstructor);
  		~complex();

		float	real	()	const;
		float	imag	()	const;
		char	arra	()	const;
		void	add		(complex a, complex b);
		void	print	();
};

complex::complex(float r, float i)
{
	re = new float;
	*re = r;

	im = new float;
	*im = i;

	iNoPointer		= 100;

	charArray	= new char[12];
	charArray = "Testausgabe";

}

complex::complex(const complex& CopyConstructor) 
{ 
    this->re = new float( CopyConstructor.real() ); 
    this->im = new float( CopyConstructor.imag() ); 
	this->charArray = new char( CopyConstructor.arra() );
}

complex::~complex()
{
	delete re;
	re = 0;

	delete im;
	im = 0;
}

char complex::arra()	const
{
	//charArray = "abcdefghijk";

	return	*charArray;
}

float complex::real()	const
{
	return *re;
}

float complex::imag()	const
{
	return *im;
}

void complex::add(complex a, complex b)
{
	*re = a.real() + b.real();
	*im = a.imag() + b.imag();
}

void complex::print()
{
	cout << "Realteil: " << *re << "			Imaginaerteil: " << *im << endl << endl;
 	cout << charArray << endl << endl;
}

Das Hauptprogramm :

#include "MyComplex.h"

int main()
{

	complex x(1.0, 2.0);
	complex y(2.0, 4.0);
	complex z(0.0, 0.0);

	x.print();
	y.print();

	z.add(x,y);

 	z.print();

	return 0;
}

Ich weiß dass das Programm für viele sinnfrei ist für mich zählen die learning purposes.

Vielen Dank für eure Mühe vorab!
Duckler

Nexus

Wie dir schon im letzten Thread erklärt wurde, ist

float    *re, *im;

kompletter Schwachsinn. Benutze keine Zeiger, wenn du sie nicht brauchst, und erst recht keine manuelle Speicherverwaltung! Zudem enden Standard-Header nie mit ".h".

Was ein char* -Array in einer komplexen Zahl verloren hat, weiss ich auch nicht. Bei iNoPointer weiss ich nicht einmal, wofür der steht...

In einer const-Methode ist das Objekt, mit dem du arbeitest, konstant. Dementsprechend sind auch all seine Member konstant, und das schließt charArray mit ein.

Wenn die Methode das Objekt verändert, gehört kein const in die Deklaration.

Nexus

Noch was:

duckler schrieb:

Ich weiß dass das Programm für viele sinnfrei ist für mich zählen die learning purposes.

Sorry, aber das ist der komplett falsche Weg. Du lernst so lauter dumme Angewohnheiten, die du dir später mühsam abgewöhnen musst. Das beginnt beim Anwendungsgebiet von Zeigern, new und delete , geht über das Implementieren der Grossen Drei bis hin zum Aufgabenbereich einer Klasse. Das sind sehr wichtige Aspekte, die dir im Programmieralltag dauernd begegnen und bei denen du wissen musst, wann sie angebracht sind und wann nicht. Wenn du grundlegende Richtlinien bereits bei Minimalbeispielen missachtest, hast du bei grösserem Code erst recht Probleme.

Warum nicht gleich richtig machen? Um dich mit Zeigern und Speichervewaltung auseinanderzusetzen, gibt es genügend sinnvolle Anwendungen. Schreib z.B. einen kleinen Container, dann kannst du einige Konzepte (darunter OOP) anwenden. Aber mach nicht zu viel auf einmal. Zeichenketten sind beispielsweise wieder ein separates Thema. Lieber wenig, dafür richtig.

krümelkacker

*seufz*

- Du hast die 3er-Regel missachtet !
- re und im sollten keine Zeiger sein !

Mach's so:

class mycomplex
{
  double re, im; // KEINE ZEIGER !
public:
  mycomplex(double r=0, double i=0) : re(r), im(i) {}
  ...
};

(keinen Kopierkonstruktor, keinen Destruktor, keinen Zuweisungsoperator! Ist alles nicht nötig, wenn Du nicht so'n Zeiger-Blödsinn machst!)

kk

duckler

Danke für eure Antworten!

Ich werds beachten!

Viele Grüße,
Duckler