C++语法系列 类和对象Ⅰ

类和对象

将事物的属性和行为写在一起，放在类里，来表现事物

const double PI = 3.14159;

class Circle{
//访问权限
public:
  
	//属性
	int r;
	
	//行为（函数）
	double getP(){
	  return 2 * PI * r;
	}
};				// ⚠️ 这里有一个分号

int main(){
	//借助Circle类，创建一个圆（即一个对象）
	Circle c1;
	c1.r = 5;
	cout << c1.getP() << endl;
}

访问权限控制

• private：成员在类内可以访问，类外不可以访问

• protected：成员在类内和继承树内可以访问，其他的不可以访问

• public：成员在类内和类外都可以访问

class Person{
	public:
	string name;
	protected:
	string car;
	private:
	int password;
	public:
	void func(){
	  name = "zhangsan";
	  car = "tuolaji";
	  password = 123456;
	}
};

int main(){
	Person p1;
	p1.name = "lisi";
	p1.car = "benchi";		//编译不通过，因为是protected修饰的
	p1.password = 123;		//编译不通过，因为是private
	return 0;
}

struct和class的区别

成员默认的访问权限不同，struct 默认为public，class默认为private，目的是为了兼容C语言的struct

class C1{
	int a;		//默认为private
};

struct S1{
	int b;		//默认为public
};

int main(){
	//class
	C1 c1;
	c1.a = 100;		//编译不通过
	
	//struct
	S1.s1;
	s1.b = 100;		//编译通过
	return 0;
}

构造函数

• 作用：构造函数用于创建对象时为成员属性赋值

• 语法

类名(){
	//...
}

• 分类
  • 按参数分
    • 有参构造
    • 无参构造
  • 按类型分
    • 普通构造
    • 拷贝构造

//拷贝构造
Person(const Person &p){		//常量引用，防止被拷贝的对象被修改
    //将传入的p的所有属性，拷贝到当前对象身上
    age = p.age;
}

• 调用

1. 括号法

 //调用无参构造方法，不加括号。
 //原因：加了括号变成了 Person p0(); 会被编译器当作函数的声明
 //（在一个函数体内，写另一个函数的声明是合法的）
 Person p0;
 Person p1(10);		//age = 10
 Person p2(p1);		//调用拷贝构造函数

2. 显示法

Person p3 = Person(10);		//有参构造
Person p4 = Person(p3);		//拷贝构造
Person(10);					//匿名对象，当前行执行完毕后，系统后立即回收匿名对象

//不要利用拷贝构造初始化匿名对象，因为编译器会将下句看作 Person p3; 重定义了p3对象
Person(p3);

3. 隐式转换法

Person p5 = 10;		//相当于 Person p5 = Person(10); 有参构造
Person p6 = p5;		//拷贝构造

析构函数

• 作用

析构函数为对象销毁前系统自动调用，执行一些清理工作

• 语法

~类名(){}

• 注意

1. 析构函数不能有参数，因此不能重载
2. 程序在对象销毁前会自动调用析构函数，无需手动调用，且只会调用一次

深拷贝与浅拷贝

//下列代码运行会出错，解决方法是重写拷贝构造函数，见被注释掉的代码
class Person {
public:
    Person() {
        cout << "无参构造调用" << endl;
    }

    Person(int age, int height) {
        this->age = age;
        this->height = new int(height);		//new出来的在堆里，返回的是地址
        cout << "有参构造调用" << endl;
    }
    
    /*Person(const Person& p) {
        cout << "拷贝构造调用" << endl;
        this->age = p.age;
        //this->height = p.height;      	//编译器默认生成的，浅拷贝
        this->height = new int(*p.height);	//正确的，不会造成运行错误的，深拷贝
    }*/

    ~Person(){		//p1、p2在栈里，所以先析构p2
        //析构函数用来将堆区开辟的数据释放
        if (height) {
            delete height;		//运行出错，因为两个height指向同一块内存，第二次delete时，就出错了
            height = nullptr;	//p2.height改为nullptr了，但p1的没有
        }
        cout << "析构函数调用" << endl;
    }

    int age;
    int* height;
};

int main() {
    Person p1(18, 181);
    Person p2(p1);      //拷贝构造未自定义，用的是编译器默认的，是浅拷贝，会把p1.height这个指针的值，也就是一个地址，拷贝给p2.height，即这两个变量指向同一块内存
    cout << p1.age << ' ' << *p1.height << endl;
    cout << p2.age << ' ' << *p2.height << endl;
    return 0;
}

总结

• 浅拷贝
  当对象在堆区申请内存，并调用拷贝构造函数时，默认的拷贝构造只会复制地址值给新对象，是浅拷贝，多个对象的成员变量指向同一块堆区内存，析构时，多次释放，导致运行出错
• 深拷贝
  在拷贝构造里，为新对象的成员变量重新申请堆区内存，并把旧的值放进去，为深拷贝

静态成员 static

• 静态成员变量
  • 所有对象共享一份同一块内存，所以也可以通过类名来访问
  • 在编译阶段就分配内存（全局区/数据段），而不是创建对象时
  • 必须类内声明，类外初始化
  • 也可以设置访问权限

class C{
public:
    static int b;
};

int C::b = 9;		//int必须要写

int main() {
    C c;
    cout << c.b << endl;		//通过对象访问
    cout << C::b << endl;		//通过类名访问
    return 0;
}

• 静态成员函数
  • 所有对象共享一个函数，所以也可以通过类名来访问
  • 静态成员函数只能访问静态成员变量。因为不创建对象，也可以通过类名来调用静态成员函数，此时，没有对象，何来普通成员变量呢？其次，就算创建了对象，通过类名调用时，也不知道访问哪个对象的变量
  • 也可以设置访问权限

PS：CSDN广告多我忍了，怎么对Markdown的支持这么差，打个无序列表各种bug。。。。。