C# · 12月 19, 2021

C++ 学习笔记-8

分清楚 declaration 和 deFinition; initializ 和 assignment

在C中可以认为 initalize 和 assignment 是一样的

但是在啊C++中是完全不一样的

在C++,int a(10); 和 int a = 10; 是等价的,两者都是初始化

构造函数的参数表如果只有一个,而且是该类对象的常引用,那么这个构造函数称为拷贝构造函数或者复制构造函数

如果没有给出复制构造函数那么编译器默认生成,默认生成的拷贝构造函数会拷贝每一个成员变量

如果这个类的成员变量是其他类的对象,那么他会让那个类的拷贝构造函数来拷贝构造那个对象

所以你的类的成员变量有其他类的对象,那么这个拷贝构造函数会被递归的下去

这个拷贝实在成员级别上的拷贝,不是在字节上的拷贝。如果有其他教科书上写的是字节级别上的拷贝,那它是错的

如果有指针的话会发生指针的拷贝,结果就是两个指针指向同一块内存

同样的道理,如果是引用,那么两个引用变量引用的是同一个

如果拷贝构造函数的参数标语是引用,那么会发生拷贝构造函数的递归

private 是针对类而不是针对 对象

Person f()

{

    Person ip;

    return ip;

}

person p = f(); 

有可能发生两种情况

    1: 直接就是 person p = ip;

    2: person tmp = ip;     p = tmp;

两种情况的发生是根据编译器的情况,有些编译器优化掉它认为不必要的拷贝构造

任何对象都只能初始化一次,之后再做相似的动作就是赋值了

在写C++程序应该尽量用string类,而不是 char *

用char * 只有一个目的,我要直接访问内存了,或者要做二进制数据

如果做得是纯字符串应该用string

建议:

    1: 写一个类,就为这个类写一个拷贝构造函数

    2: 写一个default constructor

    3: 写一个 virtual 的析构函数

    4: 不要依赖编译器给的函数

如果你的拷贝构造函数是 private 的,那么别人就无法拷贝构造你这个类的对象

java所有的对象都是通过指针来传递得到

learning record code:

#include

#include

#include

#include // #include

using namespace std;

static int objectCount = 0;

class HowMany{

public:

HowMany(){ objectCount ++; print(“HowMany()”); }

HowMany(int i) { objectCount ++; print(“HowMany()”); }

HowMany(const HowMany &h) { objectCount ++; print(“HowMany()”); }

void print(const string &msg = “”)

{

if(msg.size() != 0)

cout << msg << ": ";

cout << "ObjectCount = " << objectCount << endl;

}

~HowMany(){ objectCount –; print(“~HowMany()”); }

};

HowMany f(HowMany x)

{

cout << "begin of f" << endl;

x.print(“x argument of f()”);

cout << "end of f" << endl;

return x;

}

class Person{

private:

char *name;

public:

Person(const char *s)

{

name = new char[::strlen(s) + 1];

::strcpy(name,s);

}

~Person() { delete []name; }

Person(const Person & per)

{

name = new char[::strlen(per.name) + 1];

::strcpy(name,per.name);

}

void print();

};

void Person::print()

{

printf(“name = %pn”,name);

}

class A{

public:

A() { cout << "constructor called" << endl; }

~A() { cout << "destructor called" << endl; }

A(const A & a) { cout << "copy constructor called" << endl; }

};

A f()

{

A b;

return b;

}

int main()

{

// HowMany h;

// h.print(“afte construction of h”);

// HowMany h2 = f(h);

// h.print(“afte call to f”);

// Person p1(“zhang”);

// Person p2(p1);

// p1.print();

// p2.print();

A p = f();

return 0;

}