c 面向对象（一）

类

抽象是一种认识事物的本质

类：从对象中抽离出来的抽象
对象：具体的事物

/**
 * 类的定义
 */
class Dog{
    char name[20];
    int age;
    int type;
    void speak(){};
    void run(){};
};

访问限定符

public: 公共的
protected: 受保护的
private: 私有的

对象的实例化

1.栈中创建

    Dog dog;
    Dog dog2[20];

2.堆中创建

    Dog *dog = new Dog();
    Dog *dog2 = new Dog[20];
    //对象用完需要释放掉内存
    delete dog;
    delete []dog2;

对象成员的访问

栈中实例化对象成员的访问

    dog.age;
    dog.speak();

堆中实例化对象成员的访问

    dog -> age = 10;
    dog -> speak();
    for (int i = 0; i < 20; i++) {
        dog2[i].age = 20;
        dog2[i].speak();
    }
//堆中实例化的对象可能失败，使用之前需要判空

字符串string引入

#include <string> //需要先引入string头文件
string name = "zhangsan";
string name(zhangsan);

初始化方式

string s1; //s1为空串
string s2("ABC"); //用字符串字面值赋值
string s3(s2); //用s3初始化为s2的副本
string s4(n, 'c'); //将s4初始化为字符'c'的n个副本

常用操作

s.empty();
s.size();
s[n];
s1 + s2;
s1 = s2;
s1 == s2;
s1 != s2;
//getline(cin, name)  //获取用户输入

封装

屏蔽属性的直接访问，通过方法访问，方法里面可以加部分业务，外部可以直接访问到方法，达到间接访问属性的目的

class Student{
public:
    void setAge(int age){
        m_iAge = age;
    };
    string getName(){
        return m_strName;
    };
private:
    string m_strName;
    int m_iAge;
};

类内定义和内联函数

内联函数：编译时将函数体代码和实参代替函数调用语句，适用结构简单的函数，关键字inline
类内定义：在类中定义的方法

类外定义

成员函数体写在类外部

同文件类外定义：函数体和类定义在同一个文件中

class Dog {
public:
    char name[20];
    int age;
    int type;
    void speak();
    void run();
};
void Dog::speak() {};
void Dog::run() {};

分文件类外定义：函数体和类定义不在同一个文件中，这种方式一般比较常用

//Car.h
class Car{
public:
    void run();
    void stop();
    void changeSpeed();
};
//Car.cpp
#include "Car.h"
void Car::run() {}
void Car::stop() {}
void Car::changeSpeed() {}

内存分布

栈区：分配的内存不需要手动释放
堆区：分配的内存需要手动释放
全局区：存储全局变量及静态变量
常量区：string str = “hello world”;
代码区: 存储逻辑代码的二进制，编译后的代码

构造函数

在对象实例化时候被自动调用
与类同名
没有返回值
可以有多个重载
实例化对象时候仅用到一个构造函数
用户没有调用时候，编译器自动生成一个构造函数

class Student{
public:
    Student(){
    };
    Student(int age, string name){
    };
};
Student student;
Student student1(10, "hehe"); 
//构造函数定义的时候，可以直接定义默认值

初始化列表

特性：
1.先于构造函数执行
2.只能用于构造函数
3.可以同时初始化多个数据成员

必要性：
使用const修饰的变量必须要用初始化列表

class Student{
public:
    Student(){
    };
    Student(int age, string name): m_strName(name), m_iAge(age){
    }
    void setAge(int _age){
        m_iAge = _age;
    };
    string getName(){
        return m_strName;
    };
private:
    string m_strName;
    int m_iAge;
};

拷贝构造函数

 Student(){
    cout << "Student()" << endl;
 };
 Student(const Student& student){
    cout << "Student(const Student& student)" << endl;
 }
//实例化时候，student2和student3会自动调用拷贝构造函数
    Student student1;
    Student student2 = student1;
    Student student3(student2);

1.如果没有自定义的拷贝构造函数则系统自动生成一个默认的拷贝构造函数
2.当采用直接初始化或复制初始化实例化对象时系统自动调用拷贝构造函数

析构函数

格式：~类名()

//析构函数不允许加参数
~Student(){
    cout << "~Student" << endl;
}

1.如果没有自定义的析构函数则系统自动生成
2.在对象销毁时候，会被自动调用，用来释放内存
3.析构函数没有返回值，没有参数也不能重载

对象生命历程

申请内存 -> 初始化列表 -> 构造函数 -> 参与运算 -> 析构函数 -> 释放内存