相关疑难解决方法(0)

下面的代码是验证我是否在类中有一个指针成员,而不是重载赋值运算符.当我使两个实例相等时,它只会使指针指向同一个东西,而不是复制数据.但是,在我验证之前,我在尝试编译时遇到错误.在我看来,它暗示类中的指针成员必须指向堆分配的数据.这样对吗？

错误是:使用参数'aa'的堆栈地址初始化指针成员'a'[-Werror,-Wdangling-field]

第二个问题是我们什么时候需要一个重载的"="运算符？我想当我们在类中有一个指针成员时,我们希望再次复制指针指向的任何内容,而不是仅仅使两个类中的两个指针指向同一个东西.有人可以告诉我这是对的.谢谢!

class ClassA {    
  int* a;  
  int* b;  

  ClassA():a(NULL),b(NULL){};

  ClassA(int aa,int bb):a(&aa),b(&bb){};                                                                                                                                                                                     
};

int main(){ 

  ClassA test;
  ClassA subject(5,6);

  test = subject;
}

在C中,我们实际上做到了

struct node *p = (node*)malloc(sizeof(node));   // casting is not necessary
p->a = 0;      // first  element
p->b = NULL;   // second element

动态分配内存中的空格,但我怎么能用C++方式呢？

线下面是正确的猜测吗？

node *p = new node {0, NULL};

以下代码导致断言错误.此外,警告错误消息表示检测到堆损坏.

class A {
    int* a; // dynamic array of ints
    A() {};
    A(int size) {
        a = new int[size]; 
    }
    ~A() {
        delete [] a;
        a = nullptr;
    }
}

*** in code somewhere ***
int size = 5;
A temp = A(size);

我有两个C++构造函数和一个析构函数.当我为我的对象使用第一个构造函数时,析构函数被调用以删除A []这是我想要的,但是当我使用第二个构造函数时,我不需要调用析构函数,但C++编译器无论如何调用它会导致错误.解决这个问题的最佳方法是什么？

Tree(int n) {

  A = new int[n];
}

Tree(int data*, int n) {
   A = data;
}

~Tree(){

   delete [] A;
}

我遇到了一些代码，其中一个人重载了复制构造函数和赋值运算符，如下所示：

 Prod(const Prod& src) {  
        _id    = src._id;
        _name  = src._name;
        _group = src._group;
        ...
}

 Prod& operator=(const Prod& src) {  
        _id    = src._id;
        _name  = src._name;
        _group = src._group;
        ...
}

我觉得奇怪的是 Prod 类中的所有成员变量都不是指针。那么为什么需要像上面那样重载复制构造函数和 = 运算符呢？

这是关于std :: vector成员结构中的数组范围的问题.

假设我有下一个代码:

struct memberStruct {
...
char array[5];
...
};

std::vector <memberStruct> _workVector;

问题:哪个向量清除方法(clear/erase/pop_back)确保memberStruct.array取消分配AKA超出范围？

据我所知,当我们分配一个对象时,将调用另一个默认的复制构造函数.

class class1 obj1;
class class2 obj2;
obj1(obj2); //default copy constructor will be called by compiler 

那么,我什么时候应该明确写出复制构造函数？

将头文件中的变量声明为指针或非指针之间有什么区别？我不确定我是否正确理解这些差异.

例如

class MyClass {

private:
    MyOtherClass* moc; // pointer
    MyOtherClass moc2; // no pointer
}

到目前为止,在将变量声明为指针时,我已经提出了以下优点/缺点.

好处:

• 延迟实例化(没有立即创建对象)
• 变量存在于堆上,远远大于堆栈
• 不仅可以使用默认构造函数

缺点:

• 必须在析构函数中手动删除(顺便说一句.何时这样的非指针变量被破坏？当程序结束？)

还有什么可说的？

注意"len = strlen(s);"行中代码的差异.在代码1中:它在"strcpy(str,s)"之前写入,在代码2之后写入.它有什么不同？我在Dev C++中运行我的代码,我得到不同的输出.在两种情况下输出都不一样吗？

代码1:

#include <iostream>
#include <string.h>
using namespace std;

class String{
    private:
        char str[];
        int len;
    public:
        String()
        {
            cout << "Default Constructor" << endl;
            len = 0;
            strcpy(str,"");
        }
        String(char s[])
        {
            cout << "parameterised constructor" << endl;
            len = strlen(s);
            strcpy(str,s);
        }
        void print()
        {
            cout << str << " len = " << this->len << " strlen = " << strlen(str) << endl;
        }
};

int main()
{
    String str2("Hello World");
    str2.print();
    return 0; …

我有一堂课

class vlarray {
public:
    double *p;
    int size;

    vlarray(int n) {
        p = new double[n];
        size = n;
        for(int i = 0; i < n; i++)
            p[i] = 0.01*i;
    }

    ~vlarray() {
        cout << "destruction" << endl;
        delete [] p;
        size = 0;
    }
};

当我在主要使用

int main() {
    vlarray a(3);
    {
        vlarray b(3);
        b.p[0] = 10;
        for(int i = 0; i < 3; i++) {
            cout << *(b.p+i) << endl;
        }
        a = b;
    }    // the magic …

我分配了内存但是当我调用析构函数时,它给了我一个分段错误.这是代码.我用正确的东西来释放记忆吗？

class plan {
    char *symbol;
    gro  *grow;
  public:
    plan (int, char[] ); //constructor
    ~plan ( ); //destructor
};

plan::plan (int num_of_sm, char sm[]){
  try {
    symbol = new char [strlen(sm) + 1];
  }
  catch (std::bad_alloc) {
    symbol = NULL;
  }


  if (symbol != NULL) {
    if (sm == NULL) {
      strcpy (symbol, "");
    }
    else {
      strcpy (symbol, sm);
    }
  }
  gro = new grow [num_of_sm]; 
}

plan::~plan( ){
  delete [ ] symbol;
  delete [ ] gro;
}