OOP. Başvuru soruları - sayfa 15

Yeni yorum
 

Varsayılan bir kurucu, sınıfının bir dizi nesnesini başlatırken özel bir amaca sahiptir. Tüm parametreleri varsayılan değerlere ayarlanmış bir yapıcı, varsayılan bir makine değildir . burada .

Yazım hatasını kırmızıyla vurguladı.

Bu arada, neden böyle bir kurucu varsayılan kurucu değil? Başka bir koltuk değneği mi?

 
TheXpert :

Varsayılan bir kurucu, sınıfının bir dizi nesnesini başlatırken özel bir amaca sahiptir. Tüm parametreleri varsayılan değerlere ayarlanmış bir yapıcı, varsayılan bir makine değildir . Burada

İlginç bir yazım hatası, teşekkürler. Sabit.
 
Yedelkin :

" Geçersiz işaretçi erişimi " == " Geçersiz bir işaretçiye erişim girişiminde bulunuldu"?

Genellikle çarpık ellerin doğrudan bir işareti veya işaretçilerle çalışmanın temel ilkelerinin anlaşılmaması.

Daha az sıklıkla, sınıf kullanımının yetersiz belgelenmesinin bir işareti.

 
TheXpert :

Bu arada, neden böyle bir kurucu varsayılan kurucu değil? Başka bir koltuk değneği mi?

Tam tersi. Koltuk değneği, ince hataların kaynağı olduğu için varsayılan parametrelerin varlığıdır. Burada sadece titizlik gösterdik.

Parametreli bir kurucu yazarsanız, parametresiz bir kurucu da yazabilirsiniz. Ve eğer bir varsayılan kurucu varsa, o zaman tüm varsayılan parametrelerle parametrik bir kurucu yazmak mümkün olmayacaktır.

 
stringo :

Koltuk değneği, ince hataların kaynağı olduğu için varsayılan parametrelerin varlığıdır.

Evet, bir şekilde bu tür durumları düşünemiyorum.

Ve eğer bir varsayılan kurucu varsa, o zaman tüm varsayılan parametrelerle parametrik bir kurucu yazmak mümkün olmayacaktır.

Ah, o zaman normal ve mantıklı. Ve sonra anlaşılmaz bir ikilik ortaya çıktı.
 

Bağlam çözümleme işlemini okudum ( :: ). İlişkisiz iki sınıfta kullanmayı denemeye karar verdim:

 //+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
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;
  }

Derleyici, C_A::funcA(j) satırında bir hata atar. Eğer yorum yaparsanız, işe yaramış gibi görünüyor. Benim hatam ne?

 
Yedelkin :

Bağlam çözümleme işlemini okudum ( :: ). İlişkisiz iki sınıfta kullanmayı denemeye karar verdim:

Derleyici, C_A::funcA(j) satırında bir hata atar. Eğer yorum yaparsanız, işe yaramış gibi görünüyor. Benim hatam ne?

Sizin durumunuzda, C_A sınıfı bağlamına C_B sınıfından erişilemez.

Bu yalnızca şu durumlarda doğrudur:

 //+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
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);
     }
  };

Ama sonra şunları yapabilirsiniz:


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

Genel olarak, bu tür çağrılar aşırı yüklenmiş yöntemler için kullanılır:


//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
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;
  }

Aşağı yukarı böyle.

 
uncleVic :

Sizin durumunuzda, C_A sınıfı bağlamına C_B sınıfından erişilemez.

Teşekkür ederim. Dolayısıyla,bağlam çözümleme işleminin kalıtım olmadan uygulanabileceği konusunda yanılmışım.
 

Üye değerlerini bir sınıftan diğerine "referans yoluyla" ve bir tanımlayıcı yardımıyla geçirmeye çalışıyorum. Her iki seçenek de işe yarıyor gibi görünüyor. İşte en basit diyagram:

 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();
  }

Bu iki yöntemden hangisi daha hızlıdır? Hangisi tercih edilir?

 
Yedelkin :

Üye değerlerini bir sınıftan diğerine "referans yoluyla" ve bir tanımlayıcı yardımıyla geçirmeye çalışıyorum. Her iki seçenek de işe yarıyor gibi görünüyor. İşte en basit diyagram:

Bu iki yöntemden hangisi daha hızlıdır? Hangisi tercih edilir?

Ne, gerçekten ağır/yanlış sorular mı?

Uzun bir süre ilk yöntemi ("referans yoluyla") kullandım, ancak tanımlayıcılar hakkındaki fikri gerçekten beğendim. Sadece bu yüzden tüm dersleri yeniden yazmaya değer mi bilmiyorum.

1...8910111213141516171819
Yeni yorum
Neden: