命名空间、构造函数、析构函数、继承、初始化列表

2019-10-11 本文已影响0人叶子扬

C++.png

构造函数(Constructor)

构造函数(也叫构造器)，在对象创建的时候自动调用，一般用于完成对象的初始化工作
特点
- 函数名与类同名，无返回值(void都不能写)，可以有参数，可以重载，可以有多个构造函数
- 一旦自定义了构造函数，必须用其中一个自定义的构造函数来初始化对象
注意
- 通过malloc分配的对象不会调用构造函数
- 因为malloc是C的函数，不会调用C++的东西
一个广为流传的、很多教程\书籍都推崇的错误结论:
~~- 默认情况下，编译器会为每一个类生成空的无参的构造函数~~
- 正确理解:在某些特定的情况下，编译器才会为类生成空的无参的构造函数
- (哪些特定的情况?以后再提)

构造函数的调用

struct Person{
    int m_age;
    
    Person(){
        cout << "Person()" << endl;
    }
    Person(int age){
        cout << "Person(int age)" << endl;
    }
};

// 全局区
Person g_p1;    // 调用Person()
Person g_p2();  // 函数声明，函数名字是g_p2
Person g_p3(20);// 调用Person(int)

int main() {

    // 栈空间
    Person p1;      // 调用Person()
    Person p2();    // 函数声明，函数名字是p2
    Person p3(20);  // 调用Person(int)

    // 堆空间
    Person *p4 = new Person;    // 调用Person()
    Person *p5 = new Person();  // 调用Person()
    Person *p6 = new Person(20);// 调用Person(int)
    return 0;
}

默认情况下，成员变量的初始化

如果自定义了构造函数，除了全局区，其他内存空间的成员变量默认都不会被初始化，需要开发人员手动初始化

struct Person{
    int m_age;
};

// 全局区
Person g_p1;    // 成员标变量初始化为0

int main() {

    // 栈空间
    Person p1; // 成员标变量不初始化
    
    // 堆空间
    Person *p2 = new Person;        // 成员标变量不初始化
    Person *p3 = new Person();      // 成员标变量初始化为0
    Person *p4 = new Person[3];     // 成员标变量不初始化
    Person *p5 = new Person[3]();   // 3个对象的成员标变量初始化为0
    Person *p6 = new Person[3]{};   // 3个对象的成员标变量初始化为0
    return 0;
}

成员变量的初始化

对象初始化

Person(){
        memset(this, 0, sizeof(Person));
    }

析构函数(Destructor)

析构函数(也叫析构器)，在对象销毁的时候自动调用，一般用于完成对象的清理工作
特点：
- 函数名以~开头，与类同名，无返回值(void都不能写)，无参，不可以重载，有且只有一个析构函数
注意：
- 通过malloc分配的对象free的时候不会调用构造函数
- 构造函数、析构函数要声明为public，才能被外界正常使用

对象的内存管理

对象内部申请的堆空间，由对象内部回收
多注意setter和析构的内存管理

声明和实现分离

就是类的域不同::
略

命名空间

命名空间可以用来避免命名冲突
命名空间不影响内存布局

namespace YY {
    int g_age;
    class Person{
    public:
        
        Person(){
            cout << "Person()" << endl;
        }
        ~Person(){
            cout << "~Person()" << endl;
        }
        void run(){
            cout << "run()" << endl;
        }
    };
};
int main() {

    YY::g_age = 20;
    cout << "YY::g_age = " << YY::g_age << endl;
    
    YY::Person person = YY::Person();
    person.run();
    return 0;
}
// log:
YY::g_age = 20
Person()
run()
~Person()

思考：下边的代码能通过编译吗

namespace FX {
    int g_age;
}
namespace YY {
    int g_age;
}
int main() {
    using namespace YY;
    using namespace FX;
    g_age = 20; // 报错：Reference to 'g_age' is ambiguous
    return 0;
}

命名空间的嵌套

有个默认的全局命名空间，我们创建的命名空间默认都嵌套在它里面

namespace YY {
    namespace XX {
        int g_age;
    }
};

int g_age;

int main() {
    ::g_age = 20;
    ::YY::XX::g_age = 30;
    
    return 0;
}

namespace YY {
    namespace XX {
        int g_age;
    }
};

// 以下的用法都是合法的
int main() {
    {
        using namespace YY::XX;
        g_age = 20;
    }
    
    {
        using  YY::XX::g_age;
        g_age = 20;
    }
    
    {
        YY::XX::g_age = 20;
    }
    
    return 0;
}

命名空间的合并

以下2种写法是等价的

namespace YY {
    int g_age1;
};
namespace YY {
    int g_age2;
}

namespace YY {
    int g_age1;
    int g_age2;
}

其他编程语言的命名空间

Java : Package
Objective-C : 类前缀

继承

继承，可以让子类拥有父类的所有成员(变量\函数)
C++中没有像Java、Objective-C的基类
- Java:java.lang.Object
- Objective-C:NSObject

对象的内存布局

成员访问权限

成员访问权限、继承方式有3种
- public:公共的，任何地方都可以访问(struct默认)
- protected:子类内部、当前类内部可以访问
- prvate:私有的，只有当前类内部可以访问(class默认)
子类内部访问父类成员的权限，是以下2项中权限最小的那个
- 成员本身的访问权限
- 上一级父类的继承方式
开发中用的最多的继承方式是public，这样能保留父类原来的成员访问权限
访问权限不影响对象的内存布局

初始化列表

特点
- 一种便捷的初始化成员变量的方式
- 只能用在构造函数中
- 初始化顺序只跟成员变量的声明顺序有关
图片中的2种写法是等价的

struct Student {
    int m_age;
    int m_height;
    Student(int age, int height){
        this->m_age = age;
        this->m_height = height;
    }
};

struct Student {
    int m_age;
    int m_height;
    Student(int age, int height): m_age(age), m_height(height){}
};

思考:
m_age、m_height的值是多少

int myAge(){return 20;};
int myHeight(){return 170;};

struct Student {
    int m_age;
    int m_height;
    Student(int age, int height): m_age(myAge()), m_height(myHeight()){}
};

int main() {
    Student s(10,140);
    return 0;
}
// 20, 170

struct Student {
    int m_age;
    int m_height;
    // 警告：Field 'm_height' is uninitialized when used here
    Student(int age, int height): m_age(m_height), m_height(height){}
};

int main() {
    Student s(10,140);
    return 0;
}
// 未知、140

构造函数的互相调用

struct Student {
    int m_age;
    int m_height;
    Student():Student(0, 0){};
    Student(int age, int height): m_age(age), m_height(height){}
    
    void display(){
        cout << m_age << ", "<< m_height << endl;
    }
};

int main() {
    Student s0;
    s0.display();
    
    Student s(10,140);
    s.display();
    return 0;
}
// log:
0, 0
10, 140

注意:下面的写法是错误的，初始化的是一个临时对象

struct Student {
    int m_age;
    int m_height;
    Student(){
        Student(0, 0);
    };
    Student(int age, int height): m_age(age), m_height(height){}
    
    void display(){
        cout << m_age << ", "<< m_height << endl;
    }
};

int main() {
    Student s0;
    s0.display();
    
    Student s(10,140);
    s.display();
    return 0;
}
// log:
-272632680, 32766
10, 140

初始化列表与默认参数配合使用

如果函数声明和实现是分离的
- 初始化列表只能写在函数的实现中
- 默认参数只能写在函数的声明中

struct Student {
    int m_age;
    int m_height;
    Student(int age = 0, int height = 0): m_age(age), m_height(height){}
    
    void display(){
        cout << m_age << ", "<< m_height << endl;
    }
};

int main() {
    Student s1;
    Student s2(20);
    Student s3(20, 170);
    
    s1.display();
    s2.display();
    s3.display();
    return 0;
}
// log:
0, 0
20, 0
20, 170

父类的构造函数

子类的构造函数默认会调用父类的无参构造函数
如果子类的构造函数显式地调用了父类的有参构造函数，就不会再去默认调用父类的无参构造函数
如果父类缺少无参构造函数，子类的构造函数必须显式调用父类的有参构造函数

继承体系下的构造函数示例

struct Person {
    int m_age;
    Person(): Person(0){};
    Person(int age = 0): m_age(age) {}
};

struct Student: public Person {
    int m_no;
    Student(): Student(0, 0){};
    Student(int age, int no): Person(age), m_no(no) {}
    
    void display(){
        cout << m_age << ", "<< m_no << endl;
    }
};

int main() {
    Student s1;
    s1.display();
    
    Student s3(2,40);
    s3.display();
    
    return 0;
}
// log:
0, 0
2, 40

构造、析构顺序

构造和析构顺序相反

struct Person {
    Person(){
        cout << "Person()" << endl;
    }
    ~Person(){
        cout << "~Person()" << endl;
    }
};

struct Student: public Person {
    Student(){
        cout << "Student()" << endl;
    }
    ~Student(){
        cout << "~Student()" << endl;
    }
};

int main() {
    Student s1;
    
    return 0;
}
// log:
Person()
Student()
~Student()
~Person()

父类指针、子类指针

父类指针可以指向子类对象，是安全的，开发中经常用到(继承方式必须是public)
子类指针指向父类对象是不安全的