巴解组织。应用问题 - 页 15

新评论
 

默认构造函数有一个特定的用途，用于初始化其类的对象阵列。 一个所有参数都设置为默认的构造函数 不是 一个默认的计算机。 图特。

我把错别字用红色标出。

顺便说一下，为什么这样的构造函数不是默认的构造函数？另一个拐杖？

 
TheXpert:

一个默认的构造函数有一个特定的用途，用于初始化其类的对象阵列。 一个所有参数都设置为默认的构造函数 不是 一个默认的计算机。 这里

有趣的错别字，谢谢。纠正了。
 
Yedelkin:

"无效的指针访问" =="试图访问一个无效的指针"？

往往是手气不好或不了解用指针工作的基本原则的直接表现。

不太常见的是类的使用记录不全的标志。

 
TheXpert:

顺便问一下，为什么这个构造函数不是一个默认的构造函数？另一个拐杖？

恰恰相反。拐杖是有默认参数，因为这是一个难以发现的bug的来源。这就是我们严格的地方。

如果你写一个带参数的构造函数，你也能够写一个无参数的构造函数。而如果你有一个默认的构造函数，你就不能用所有的默认参数写一个参数化的构造函数。

 
stringo:

拥有默认参数是一个拐杖，因为这是一个难以捕捉的bug的来源。

是的，不知何故，我想不出任何这样的情况。

而如果有一个默认的构造函数，你就不能用所有的默认参数写一个参数化的构造函数。

啊，那就很正常，很符合逻辑。否则就会出现某种难以理解的模糊不清的情况。
 

我读到了关于上下文解决的操作（::）。我决定尝试在两个不相关的班级使用它。

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

编译器在C_A::funcA(j)一行给出了一个错误。如果我把它注释出来，似乎就可以了。我的错误是什么？

 
Yedelkin:

我读到了关于上下文解决的操作（::）。我决定尝试在两个不相关的班级使用它。

编译器在C_A::funcA(j)一行给出了一个错误。如果我把它注释出来，似乎就可以了。我的错误是什么？

在你的案例中，C_A类的上下文是无法从C_B类中获得的。

只有在以下情况下才是正确的。

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

但后来它可以。


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

一般来说，这种调用是用于重载方法 的。


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

大约是这样的。

 
uncleVic:

在你的案例中，C_A类的上下文是无法从C_B类中获得的。

谢谢你。所以我错了，上下文解析操作 可以不通过继承来应用。
 

我正试图 "通过引用 "并使用描述符将成员值从一个类传递到另一个类。这两种变体似乎都能发挥作用。这里是最简单的方案。

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

这两种方法中哪一种效果更快？哪一个更可取？

 
Yedelkin:

我正试图 "通过引用 "并使用描述符将成员值从一个类传递到另一个类。这两种变体似乎都能发挥作用。这里是最简单的方案。

这两种方法中哪一种效果更快？哪个更可取？

这些问题真的很重/不正确吗？

在很长一段时间里，我使用第一种方式（"跟随链接"），但我非常喜欢描述词的想法。只是不知道是否值得因此而重写所有课程。

1...8910111213141516171819
新评论