C++类和对象

C++面向对象的三大特性：封装、继承、特性

一、封装

1、封装的意义：

  将属性和行为作为一个整体，表现生活中的事物

  将属性和行为加以权限控制

class 类名
{
    //访问权限
    //公共权限
public:
    //属性
}

以下是举例——设计一个圆类，求圆的周长

#include"iostream"
using namespace std;

const double PI = 3.14;

class Circle {
public:

    int Circle_r;

	double Circle_long()
	{
		return 2 * PI * Circle_r;
	}
};

int main() {
	Circle circle;
	circle.Circle_r = 10;

	cout << circle.Circle_long() << endl;
}

注意：

    类中的属性和行为 我们统一成为   成员

    属性：成员属性 成员变量

    行为：成员规则 成员方法

2、访问权限：

  a. pubilc     公共权限

  b. protect   保护权限    类内可以访问，类外不可以访问

  c. private    私有权限    类内可以访问，类外不可以访问

3、struct 和 class 区别

在C++中struct和class唯一的区别就在于默认的访问权限不同

struct 默认权限为公共

class 默认权限为私有

4、成员属性设置为私有

优点1：将所有成员属性设置为私有，可以自己控制读写权限

优点2：对于写权限，我们可以监测数据的有效性

二、对象特性

1、构造函数

    主要用于创建对象时为对象的成员属性赋值，构造函数由编译器自动调用，无需手动调用。

构造函数语法：类名（）{}

    a构造函数，没有返回值也不写void

    b函数名称与类名相同

    c构造函数可以有参数，因此可以发生重载

    d程序在调用对象时候会自动调用构造，无需手动调用，而且只会调用一次

2、析构函数

  主要作用在对象销毁前系统自动调用，执行一些清理工作

析构函数语法：~类名（）{}

a析构函数，没有返回值也不写void

b函数名称与类名相同，在名称前加上符号~

c析构函数不可以有参数，因此不可以发生重载

d程序在对象销毁前会自动调用析构，无序手动调用，而且只会调用一次

3、构造函数的分类和调用

两种分类方式：

按参数：有参构造和无参构造（默认构造）

按类型：普通构造和拷贝构造

三种调用方式：括号法、显示法、隐式转换法

#include<iostream>
using namespace std;


class Person {
	
public:

	Person(){
	
		cout << "无参构造函数的调用" << endl;
	}//无参构造函数
	
	Person(int a){
		
		cout << "有参构造函数的调用" << endl;
	}//有参构造函数
	
	Person(const Person& p) {

		cout << "拷贝构造函数的调用" << endl;
	}//拷贝构造函数

	~Person() {
		cout << "析构函数的调用" << endl;
	}
};

//调用：括号法
void test01() {

	Person p1;//默认构造函数的调用
	Person p2(10);//有参构造函数的调用
	Person p3(p2);//拷贝构造函数的调用
}

//调用：显示法
void test02() {
	Person p1;
	Person p2 = Person(10);
	Person p3 = Person(p2);
}

//调用：隐式转换法
void test03() {
	Person p2 = 10;//相当于：Person p2 = Person(10);
	Person p3 = p2;
}

int main() {
	test01();
	test02();
	test03();
}

注意：

调用默认构造函数的时候，不要加（）

不要利用拷贝构造函数，初始化匿名对象

4、拷贝构造函数的调用时机

C++中拷贝构造函数调用时机通常由三种情况

 a 使用一个已经创建完毕的对象来初始化一个新的对象

 b 值传递的方式给函数参数传值

 c 以值传递的方式返回局部对象

#include"iostream"
using namespace std;

class Copy_func {
public:
	
	int m_age;
	
	Copy_func() {
		cout << "默认构造函数的调用" << endl;
	}

	Copy_func(int age) {
		cout << "有参构造函数的调用"<<endl;
		m_age = age;
	}

	~Copy_func() {
		cout << "析构函数的调用" << endl;
	}
	Copy_func(const Copy_func& p) {
		cout << "拷贝构造函数的调用"<<endl;
		m_age = p.m_age;
	}

};

//使用一个已经创建完毕的对象来初始化一个新的对象
void test01() {
	Copy_func p1(10);
	Copy_func p2(p1);

	cout << "p2的年龄：" << p2.m_age << endl;
}

//值传递的方式给函数参数传值
void Work(Copy_func p) {

}

void test02() {
	Copy_func p;
	Work(p);
}

//值方式返回局部对象
Copy_func work1() {
	Copy_func p;
	return p;
}

void test03() {
	Copy_func p = work1();
}

int main() {

	//test01();
	//test02();
	test03();
}

5。构造函数调用规则

默认情况下，C++编译器至少给一个类添加3个函数

 a 默认构造函数（无参，函数体为空）

 b 默认析构函数（无参，函数体为空）

 c 默认拷贝构造函数，对属性进行值拷贝

构造函数调用规则如下：

    如果用户定义有参构造函数，C++不在提供默认无参构造，但是会提供默认拷贝构造

    如果用户定义拷贝构造函数，C++不会再提供其他构造函数