Zeiger als Member deklarieren

MuehBln

poste doch einfach mal die ganze Klasse...

bolilein

Danke für deine Interesse MuehBln !!

Hier die komplette Klasse (NICHTS Wildes) :
Es sind lediglich einige Memberfunktionen die einige Members setzten oder lesen.

HEADER :

const int NPOINTS = 1601;

class CData  
{
public:
   void SetNPOINTS(int NPOINTS);
   int GetNPOINTS();

   void SetFrequency(int n,double f);
   double GetFrequency(int n);

   void SetS11(int n,double Re,double Im);
   void SetS12(int n,double Re,double Im);
   void SetS21(int n,double Re,double Im);
   void SetS22(int n,double Re,double Im);

   double GetS11Re(int n);   
   double GetS12Re(int n);   
   double GetS21Re(int n);   
   double GetS22Re(int n);   

   double GetS11Im(int n);   
   double GetS12Im(int n);   
   double GetS21Im(int n);   
   double GetS22Im(int n);   

   void SetS11Angle(int n,double Angle);
   void SetS12Angle(int n,double Angle);
   void SetS21Angle(int n,double Angle);
   void SetS22Angle(int n,double Angle);

   double GetS11Angle(int n);
   double GetS12Angle(int n);
   double GetS21Angle(int n);   
   double GetS22Angle(int n);

   void SetS11Abs(int n,double Abs);
   void SetS12Abs(int n,double Abs);
   void SetS21Abs(int n,double Abs);
   void SetS22Abs(int n,double Abs);

   double GetS11Abs(int n);
   double GetS12Abs(int n);
   double GetS21Abs(int n);   
   double GetS22Abs(int n);

   void Setfafe(double fa,double fe);

   CData();
   virtual ~CData();

private:
   int m_iNPOINTS;

   double m_fa;
   double m_fe;
   double m_Frequency[NPOINTS];

   double m_dS11Angle[NPOINTS];
   double m_dS12Angle[NPOINTS];
   double m_dS21Angle[NPOINTS];
   double m_dS22Angle[NPOINTS];

   double m_dS11Abs[NPOINTS];
   double m_dS12Abs[NPOINTS];
   double m_dS21Abs[NPOINTS];
   double m_dS22Abs[NPOINTS];

   CComplexNumber m_S11[NPOINTS];
   CComplexNumber m_S12[NPOINTS];
   CComplexNumber m_S21[NPOINTS];
   CComplexNumber m_S22[NPOINTS];
};

CPP Implementierung:

void CData::Setfafe(double fa,double fe)
{
   m_fa = fa;
   m_fe = fe;
}

void CData::SetFrequency(int n, double f)
{
   m_Frequency[n] = f;   
}

double CData::GetFrequency(int n)
{
   return m_Frequency[n];
}

void CData::SetS11(int n, double Re, double Im)
{
   m_S11[n].SetReIm(Re,Im);
}

void CData::SetS12(int n, double Re, double Im)
{
   m_S12[n].SetReIm(Re,Im);
}

void CData::SetS21(int n, double Re, double Im)
{
   m_S21[n].SetReIm(Re,Im);
}

void CData::SetS22(int n, double Re, double Im)
{
   m_S22[n].SetReIm(Re,Im);
}

double CData::GetS11Re(int n)
{
   return m_S11[n].GetRe();
}

double CData::GetS12Re(int n)
{
   return m_S12[n].GetRe();
}

double CData::GetS21Re(int n)
{
   return m_S21[n].GetRe();
}

double CData::GetS22Re(int n)
{
   return m_S22[n].GetRe();
}

double CData::GetS11Im(int n)
{
   return m_S11[n].GetIm();
}

double CData::GetS12Im(int n)
{
   return m_S12[n].GetIm();
}

double CData::GetS21Im(int n)
{
   return m_S21[n].GetIm();
}

double CData::GetS22Im(int n)
{
   return m_S22[n].GetIm();
}

int CData::GetNPOINTS()
{
   return m_iNPOINTS;
}

void CData::SetNPOINTS(int NPOINTS)
{
   m_iNPOINTS = NPOINTS;
}

double CData::GetS11Angle(int n)
{
   return m_dS11Angle[n];
}

double CData::GetS12Angle(int n)
{
   return m_dS12Angle[n];
}

double CData::GetS21Angle(int n)
{
   return m_dS21Angle[n];
}

double CData::GetS22Angle(int n)
{
   return m_dS22Angle[n];
}

void CData::SetS11Angle(int n,double Angle)
{
   m_dS11Angle[n] = Angle;   
}

void CData::SetS12Angle(int n,double Angle)
{
   m_dS12Angle[n] = Angle;   
}

void CData::SetS21Angle(int n,double Angle)
{
   m_dS21Angle[n] = Angle;   
}

void CData::SetS22Angle(int n,double Angle)
{
   m_dS22Angle[n] = Angle;   
}

double CData::GetS11Abs(int n)
{
   return m_dS11Abs[n];
}

double CData::GetS12Abs(int n)
{
   return m_dS12Abs[n];
}

double CData::GetS21Abs(int n)
{
   return m_dS21Abs[n];
}

double CData::GetS22Abs(int n)
{
   return m_dS22Abs[n];
}

void CData::SetS11Abs(int n,double Abs)
{
   m_dS11Abs[n] = Abs;   
}

void CData::SetS12Abs(int n,double Abs)
{
   m_dS12Abs[n] = Abs;   
}

void CData::SetS21Abs(int n,double Abs)
{
   m_dS21Abs[n] = Abs;   
}

void CData::SetS22Abs(int n,double Abs)
{
   m_dS22Abs[n] = Abs;   
}

Gruß bolilein

[ Dieser Beitrag wurde am 25.06.2003 um 15:46 Uhr von bolilein editiert. ]

[ Dieser Beitrag wurde am 25.06.2003 um 15:47 Uhr von bolilein editiert. ]

[ Dieser Beitrag wurde am 08.07.2003 um 12:55 Uhr von bolilein editiert. ]

dEUs

erfolgt die zuweiseung mit new sicher vor dem aufruf der memberfunktion auf m_pData?

MuehBln

würde auch sagen, dass Du versuchst auf m_pDate zuzugreifen, bevor Speicher mit new reserviert wurde.
Interessant wäre übrigens die Klasse, in der Du CData verwendest (mit C++Code Tags!)

Gruß
Chris

bolilein

Danke euch erstmal,

Ich habe diese Vorgehensweise nicht weiter verfolgt sondern die Sache anders gelöst.

Trotzdem noch mal die Szenario:

In einer SDI Anwendung soll innerhalb der CView Klasse ein Zeiger vom Typ CData als MEMBER deklariert werden (CData *m_pData). Die Klasse CData wird in der View.cpp includiert.

Die new zuweisung erfolgt innerhalb einer Funktion der CView Klasse.

m_pData = new CData;

Wenn man dann die Werte von m_pData setzen will so gibt es ärger.

Ich muß nochmal prüfen ob euere Vorschläge zutrefen könnten,
Danke euch
meld mich später

bolilein

RHBaum

Nur am Rande ...

Wenn CView genau eine Instanz von CData halten soll, und diese beim erzeugen von CView mit erstellt, und beim zerstoeren mit weggeworfen werden soll ... warum dann dynamisch ??? (so klingt das was ich hier lese)
dynamisch "lohnt" sich in den meisten Standardfaellen nur ... wenn man Variable anzahl von Instanzen braucht ... oder man nen Ungueltigkeitsidentifikator brauch, oder wenn deine Instanz viel speicher schluckt und wirklich viel kuerzer zu leben braucht als die Conatainerklasse.

Oder gibt es spezielle gruende, warum CData dynamisch instanziert werden soll ???

Ciao ...

bolilein

Danke für die Antworten!

Die new Zuweisung erfolgte schon vor dem Zugriff auf die Member-Funktion von
m_pData. Denn sowohl die Zuweisung als auch der Zugriff wurde in eine Funktion untergebracht.

Vielleicht nochmal die Szenario:

In der Header Datei wird ein Zeiger deklariert und natürlich auch "Data.h" includiert.

#include "data.h"

    CData *m_pData;

In der cpp Datei innerhalb einer Funktion erfolgt dann die Zuweisung und der Zugriff.

m_pData = new CData;
    m_pData.GetFrequency();

Ja und bei dem Zugriff gibts probleme !!

Was auch wichtig ist. WENN m_pData NICHT als Member deklariert ist sondern einfach nur lokal in der Funktion erzeugt wird, dann geht es ohne weiteres ?!?!
Also wenn da steht:

CData pData = new CData;
    pData.GetFrequency();

Das finde ich schon sehr komisch ???

Gruß Bolilein

RenéG

CData pData = new CData;
pData.GetFrequency();

Also einer von uns beiden sollte sich nochmal mit den Grundlagen von C++ beschäftigen.

XZ59

nimm mal die Deklaration deines Pointers in eine cpp-Datei auf und nicht in den Header, soweit ich mich erinner kann es da nur krachen ... korrigiert mich, falls ich falsch liege.

und

pData.GetFrequency();

sollte wohl

pData->GetFrequency();

heißen

bolilein

Sorry RenéG und XZ59

Ich sehe, daß ich zum einen wieder das Sternchen vergessen habe und nicht beim Zeigern übliche Pfeil-Operator benutzt habe.

Ich war letztes mal etwas in eile und habe die Sachen etwas schlampig eingegeben. Das ist es aber nicht!! Wie gesagt ich erhalte KEINEN Compiler- Fehler. An falsch geschriebenen Source Code kann es nicht liegen.

Wenn ihr eine gute Idee habt, so beantwortet mir BITTE warum das mit lokal deklarierter Zeiger funktioniert aber als MEMBER deklarierte Zeiger NICHT ???
Das ist doch die Interessante Frage !!!

Also der Code ist vom Syntax her 100% O.K , ich weiß wie man Zeiger deklariert und auf die Member zugreift .

Danke bolilein