PLO. Fragen zur Anwendung - Seite 15

Neuer Kommentar
 

Der Standardkonstruktor hat einen bestimmten Zweck, nämlich die Initialisierung eines Arrays von Objekten seiner Klasse. Ein Konstruktor, bei dem alle Parameter auf Standard gesetzt sind, istkein Standardcomputer. Tut.

Ich habe ein Versehen in Rot hervorgehoben.

Übrigens, warum ist ein solcher Konstruktor nicht standardmäßig ein Konstruktor? Eine weitere Krücke?

 
TheXpert:

Ein Standardkonstruktor hat einen bestimmten Zweck, nämlich die Initialisierung einer Reihe von Objekten seiner Klasse. Ein Konstruktor, bei dem alle Parameter auf Standard gesetzt sind, istkein Standardcomputer. Hier

Interessanter Tippfehler, danke. Korrigiert.
 
Yedelkin:

"Ungültiger Zeigerzugriff" =="Versuch des Zugriffs auf einen ungültigen Zeiger"?

Oft ein direktes Zeichen für ein schlechtes Blatt oder mangelndes Verständnis der Grundprinzipien der Arbeit mit Zeigern.

Seltener ein Zeichen für eine schlecht dokumentierte Klassenverwendung.

 
TheXpert:

Übrigens, warum ist dieser Konstruktor nicht ein Standardkonstruktor? Eine weitere Krücke?

Ganz im Gegenteil. Die Krücke ist die Verwendung von Standardparametern, da dies eine Quelle für schwer zu findende Fehler ist. In diesem Punkt sind wir streng.

Wenn Sie einen Konstruktor mit Parametern schreiben, können Sie auch einen parameterlosen Konstruktor schreiben. Und wenn Sie einen Standardkonstruktor haben, können Sie keinen parametrischen Konstruktor mit allen Standardparametern schreiben.

 
stringo:

Es ist eine Krücke, Standardparameter zu haben, da dies eine Quelle von schwer zu fangenden Fehlern ist.

Ja, irgendwie kann ich mir keine solche Situation vorstellen.

Und wenn es einen Standardkonstruktor gibt, kann man keinen parametrischen Konstruktor mit allen Standardparametern schreiben.

Ah, dann ist das normal und logisch. Ansonsten gab es eine unverständliche Zweideutigkeit.
 

Ich habe überden Vorgang der Kontextauflösung gelesen( ::: ).Ich habe mich entschlossen, es in zwei nicht miteinander verbundenen Klassen zu verwenden:

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
class C_B;
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
class C_A
  {
public:
   C_B              *pointer;

                     C_A(void) {};
                    ~C_A(void) {};
   void funcA(int i) { Print("funcA(",i,")=",i); }
  };
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
class C_B
  {
public:
                     C_B(void) {};
                    ~C_B(void) {};
   void funcB(int j)
     {
      Print("funcB(",j,")=",j);
      C_A::funcA(j);
     }
  };
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void OnStart()
  {
   C_A object;
   object.pointer=new C_B();
   object.pointer.funcB(5);
   delete object.pointer;
  }

Der Compiler gibt einen Fehler in der Zeile C_A::funcA(j) aus. Wenn ich es auskommentiere, scheint es zu funktionieren. Was ist mein Fehler?

 
Yedelkin:

Ich habe überden Vorgang der Kontextauflösung gelesen( ::: ).Ich beschloss, es in zwei nicht miteinander verbundenen Klassen zu verwenden:

Der Compiler gibt einen Fehler in der Zeile C_A::funcA(j) aus. Wenn ich es auskommentiere, scheint es zu funktionieren. Was ist mein Fehler?

In Ihrem Fall ist der Kontext der Klasse C_A nicht in der Klasse C_B verfügbar.

Es ist nur richtig, wenn:

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
class C_B : public C_A
  {
public:
                     C_B(void) {};
                    ~C_B(void) {};
   void funcB(int j)
     {
      Print("funcB(",j,")=",j);
      C_A::funcA(j);
     }
  };

Aber dann ist es möglich:


//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
class C_B : public C_A
  {
public:
                     C_B(void) {};
                    ~C_B(void) {};
   void funcB(int j)
     {
      Print("funcB(",j,")=",j);
      funcA(j);
     }
  };

Im Allgemeinen werden solche Aufrufe für überladene Methoden verwendet:


//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
class C_B;
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
class C_A
  {
public:
   C_B              *pointer;

                     C_A(void) {};
                    ~C_A(void) {};
   void func(int i) { Print("C_A::func(",i,")=",i); }
  };
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
class C_B : public C_A
  {
public:
                     C_B(void) {};
                    ~C_B(void) {};
   void func(int j)
     {
      Print("C_B::func(",j,")=",j);
      C_A::func(j);
     }
  };
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void OnStart()
  {
   C_A object;
   object.pointer=new C_B();
   object.pointer.func(5);
   delete object.pointer;
  }

Ungefähr so.

 
uncleVic:

In Ihrem Fall ist der Kontext der Klasse C_A nicht in der Klasse C_B verfügbar.

Ich danke Ihnen. Ich habe mich also geirrt, dass die Kontextauflösungsoperation ohne Vererbung angewendet werden kann.
 

Ich versuche, Memberwerte von einer Klasse an eine andere "per Referenz" und unter Verwendung eines Deskriptors zu übergeben. Beide Optionen scheinen zu funktionieren. Hier ist das einfachste Schema:

class B
  {
private:
   double            d1;
public:
                     B(double &d) {  d1=d; Print("class B, double d1=",d1);  };
                    ~B(void){};
  };
class A
  {
public:
   double            double_var;
   A                *pointerA;
 

                     A(void) : double_var(1.234567),pointerA(NULL) { SetPointer(); };
                    ~A(void) {if(CheckPointer(pointerA)==POINTER_DYNAMIC) delete pointerA; };
private:
   void SetPointer(void) { pointerA=GetPointer(this); }
  };
class C 
  {
public:
   A                *pointerA_C;
public:
                     C(void) : pointerA_C(NULL) {};
                    ~C(void) {if(CheckPointer(pointerA_C)==POINTER_DYNAMIC) delete pointerA_C;};
   void Printer() {if(CheckPointer(pointerA_C)!=POINTER_INVALID) Print("class C, double =",pointerA_C.double_var); };
  };
void OnStart()
  {
   A objA;
//---передаём значение double-переменной по ссылке
   B objB(objA.double_var);
//---передаём значение double-переменной через описатель
   C objC;
   objC.pointerA_C=objA.pointerA;
   objC.Printer();
  }

Welche dieser beiden Methoden funktioniert schneller? Was ist vorzuziehen?

 
Yedelkin:

Ich versuche, Memberwerte von einer Klasse an eine andere "per Referenz" und unter Verwendung eines Deskriptors zu übergeben. Beide Varianten scheinen zu funktionieren. Hier ist das einfachste Schema:

Welche dieser beiden Methoden funktioniert schneller? Was ist vorzuziehen?

Sind die Fragen wirklich schwer/unrichtig?

Lange Zeit habe ich den ersten Weg gewählt ("dem Link folgen"), aber die Idee der Deskriptoren gefällt mir sehr. Ich weiß nur nicht, ob es sich lohnt, deswegen alle Klassen umzuschreiben.

1...8910111213141516171819
Neuer Kommentar
Grund der Beschwerde: