C++ 面向对象-类和对象

其他 2021-11-19 07:09:47 阅读次数: 0

C++ 类和对象

前言

类和对象是C向C++转变的一个关键点，我写这一篇博文，以此记录自己的学习。

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

C++认为万事万物都皆为对象，对象上有其属性和行为

例如：

​ 人可以作为对象，属性有姓名、年龄、身高、体重…，行为有走、跑、跳、吃饭、唱歌…

​ 车也可以作为对象，属性有轮胎、方向盘、车灯…,行为有载人、放音乐、放空调…

​ 具有相同性质的对象，我们可以抽象称为类，人属于人类，车属于车类

一、类和结构体

说到类不得不提起的就是结构体，我们可以思考几个问题：

1.结构体能继承吗？
2.结构体能够包括成员函数吗？
3.结构体能够实现多态吗？

众所周知：能，这些结构体都能做。那么，问题来了，所以？？？大人，为什么还需要类？

如果有人这样问我，我会回答：万事万物的存在都是有它的道理的，如果你真要我说出它们两个的区别，我就只能告诉你：struct 默认权限为公共，class 默认权限为私有，具体为：

1）默认的继承访问权限，struct是public的，class是private的。

我们以下列代码为例：

struct A
{
    
    
    int a;
};
struct B : A
{
    
    
    int b;
};

这个时候 B 是公开的继承 A 的。如果都将上面的 struct 改成 class，那么 B 是 private 继承 A 的。这就是默认的继承访问权限。

所以我们在平时写类继承的时候，通常会这样写：

struct B : public A//指明是 public 继承，而不是用默认的 private 继承

当然，到底默认是 public 继承还是 private 继承，取决于子类而不是父类。

意思是，struct 可以继承 class，同样 class 也可以继承 struct，那么默认的继承访问权限是看子类到底是用的 struct 还是 class。如下：

struct A{
    
    }; 
class B : A{
    
    }; //private继承
struct C : B{
    
    }; //public继承

2）struct作为数据结构的实现体，它默认的数据访问是public的，而class作为对象的实现体，它默认的成员变量访问控制是private的。

3）struct里面不包含构造函数（或虚函数）的时候，定义之后能用{}赋值，class不管怎样都不能用{}赋值。如：

struct Student//定义一个struct
{
    
    
    int age;
    string name;
};
Student s={
    
    18,"张"}; //定义时直接赋值

那为什么在struct里面加构造函数（或虚函数）就不能用{}进行赋值了？

我这里说出我的一点看法如果有不对的麻烦指出呀，谢谢了。

在我们看来，以 {} 的方式来赋初值，只是用一个初始化列表来对数据进行按顺序的初始化。这样简单的 copy 操作，只能发生在简单的数据结构上，而不应该放在对象上。加入一个构造函数或是一个虚函数会使 struct 更体现出一种对象的特性，而使此{}操作不再有效。正因为加入这样的函数，使得struct的内部结构发生了变化。而加入一个普通的成员函数呢？你会发现{}依旧可用。其实我们可以将普通的函数理解成对数据结构的一种算法，这并不打破它数据结构的特性。

那为什么我们在上面仅仅将 struct 改成 class，就不能用{} 初始化赋值了呢？

访问控制！！！对，将 struct 改成 class 的时候，访问控制由 public 变为 private 了，那当然就不能用 {} 来赋初值了。加上一个 public，你会发现，class 也是能用 {} 的，和 struct 毫无区别！！！

二、封装

2.1 封装的意义

封装是C++面向对象三大特性之一

封装的意义：

  • 将属性和行为作为一个整体，表现生活中的事物
  • 将属性和行为加以权限控制

语法： class 类名{ 访问权限： 属性 / 行为 };

示例1：设计一个圆类，求圆的周长

//圆周率
const double PI = 3.14;
//将属性和行为作为一个整体，用来表现生活中的事物

//封装一个圆类，求圆的周长
//class代表设计一个类，后面跟着的是类名
class Circle
{
    
    
public:  //公共权限
	//属性
	int m_r;//半径
	
	//行为
	//获取到圆的周长
	double getZC()
	{
    
    
		//2 * pi  * r
		//获取圆的周长
		return  2 * PI * m_r;
	}
};

int main() {
    
    

	//通过圆类，创建圆的对象
	// c1就是一个具体的圆
	Circle c1;
	c1.m_r = 10; //给圆对象的半径 进行赋值操作
	//2 * pi * 10 = = 62.8
	cout << "圆的周长为： " << c1.getZC() << endl;X
	system("pause");
	return 0;
}

示例2：设计一个学生类，属性有姓名和学号，可以给姓名和学号赋值，可以显示学生的姓名和学号

#include <iostream>
using namespace std;
#include <string>

//设计一个学生类，属性有姓名和学号，可以给姓名和学号赋值，可以显示学生的姓名和学号
class Student
{
    
    
public:
	//行为
	void setName(string name)
	{
    
    
		m_Name = name;
	}
	string getName()
	{
    
    
		return m_Name;
	}

	void setId(int id)
	{
    
    
		m_Id = id;
	}
	int getId()
	{
    
    
		return m_Id;
	}

	//属性
private:
	string m_Name;
	int m_Id;
};
int main()
{
    
    
	//类实例化成对象
	Student s1;
	s1.setName("张三 ");
	s1.setId(1000);
	cout << "姓名为：" << s1.getName() << "学号为：" << s1.getId() << endl;
	system("pause");
	return 0;
}

2.2 访问权限

访问权限分为：

  1. public 公共权限
  2. protected 保护权限
  3. private 私有权限
    示例：
//三种权限
//公共权限  public     类内可以访问  类外可以访问
//保护权限  protected  类内可以访问  类外不可以访问
//私有权限  private    类内可以访问  类外不可以访问
class Person
{
    
    
	//姓名  公共权限
public:
	string m_Name;

	//汽车  保护权限
protected:
	string m_Car;
	
	//银行卡密码  私有权限
private:
	int m_Password;

public:
	void func()
	{
    
    
		m_Name = "张三";
		m_Car = "拖拉机";
		m_Password = 123456;
	}
};

int main() {
    
    

	Person p;
	p.m_Name = "李四";
	//p.m_Car = "奔驰";  //保护权限类外访问不到
	//p.m_Password = 123; //私有权限类外访问不到

	system("pause");
	return 0;
}

一般的，我们会将成员属性设置为私有，这样的优点如下：

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

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

示例：

class Person {
    
    
public:
	//姓名设置可读可写
	void setName(string name) {
    
    
		m_Name = name;
	}
	string getName()
	{
    
    
		return m_Name;
	}

	//获取年龄 
	int getAge() {
    
    
		return m_Age;
	}
	//设置年龄
	void setAge(int age) {
    
    
		if (age < 0 || age > 150) {
    
    
			cout << "你个老妖精!" << endl;
			return;
		}
		m_Age = age;
	}
	
	//情人设置为只写
	void setLover(string lover) {
    
    
		m_Lover = lover;
	}

private:
	string m_Name; //可读可写  姓名
	
	int m_Age; //只读  年龄

	string m_Lover; //只写  情人
};

int main() {
    
    

	Person p;
	//姓名设置
	p.setName("张三");
	cout << "姓名： " << p.getName() << endl;

	//年龄设置
	p.setAge(50);
	cout << "年龄： " << p.getAge() << endl;

	//情人设置
	p.setLover("李四");
	//cout << "女朋友： " << p.m_Lover << endl;  //只写属性，不可以读取

	system("pause");

	return 0;
}

三、对象特性

  • 生活中我们买的电子产品都基本会有出厂设置，在某一天我们不用时候也会删除一些自己信息数据保证安全.
  • C++中的面向对象来源于生活，每个对象也都会有初始设置以及对象销毁前的清理数据的设置。
    由此就引出C++中的构造函数和析构函数：

3.1 构造函数和析构函数

对象的初始化和清理也是两个非常重要的安全问题

​ 一个对象或者变量没有初始状态，对其使用后果是未知

​ 同样的使用完一个对象或变量，没有及时清理，也会造成一定的安全问题

C++利用了构造函数和析构函数解决上述问题，这两个函数将会被编译器自动调用，完成对象初始化和清理工作。

对象的初始化和清理工作是编译器强制要我们做的事情，因此如果我们不提供构造和析构，编译器会提供，但是编译器提供的构造函数和析构函数是空实现。

  • 构造函数：主要作用在于创建对象时为对象的成员属性赋值，构造函数由编译器自动调用，无须手动调用。
  • 析构函数：主要作用在于对象销毁前系统自动调用，执行一些清理工作。

构造函数语法：类名(){}

  1. 构造函数，没有返回值也不写void
  2. 函数名称与类名相同
  3. 构造函数可以有参数，因此可以发生重载
  4. 程序在调用对象时候会自动调用构造，无须手动调用,而且只会调用一次

析构函数语法： ~类名(){}

  1. 析构函数，没有返回值也不写void
  2. 函数名称与类名相同,在名称前加上符号 ~
  3. 析构函数不可以有参数，因此不可以发生重载
  4. 程序在对象销毁前会自动调用析构，无须手动调用,而且只会调用一次

示例：
这个案例用来表示 构造函数和析构函数都是会自动调用的。无需要我们手动调用。

class Person
{
    
    
public:
	//构造函数
	Person()
	{
    
    
		cout << "Person的构造函数调用" << endl;
	}
	//析构函数
	~Person()
	{
    
    
		cout << "Person的析构函数调用" << endl;
	}
};

void test01()
{
    
    
	Person p;//创建一个对象
}

int main() {
    
    
	
	test01();
	system("pause");
	return 0;
}

3.2 构造函数的分类及调用

两种分类方式：

​ 按参数分为： 有参构造和无参构造

​ 按类型分为： 普通构造和拷贝构造

三种调用方式：

​ 括号法（常用）

​ 显示法

​ 隐式转换法

示例：

//1、构造函数分类
// 按照参数分类分为 有参和无参构造   无参又称为默认构造函数
// 按照类型分类分为 普通构造和拷贝构造
class Person {
    
    
public:
	//无参（默认）构造函数
	Person() {
    
    
		cout << "无参构造函数!" << endl;
	}
	//有参构造函数
	Person(int a) {
    
    
		age = a;
		cout << "有参构造函数!" << endl;
	}
	//拷贝构造函数
	Person(const Person& p) {
    
    
		age = p.age;
		cout << "拷贝构造函数!" << endl;
	}
	//析构函数
	~Person() {
    
    
		cout << "析构函数!" << endl;
	}
public:
	int age;
};
//2、构造函数的调用
//调用无参构造函数
void test01() {
    
    
	Person p; //调用无参构造函数
}

//调用有参的构造函数
void test02() {
    
    

	//2.1  括号法，常用
	//Person p1(10);
	//注意1：调用无参构造函数不能加括号，如果加了编译器认为这是一个函数声明
	//Person p2();

	//2.2 显式法
	Person p1；//无参构造
	Person p2 = Person(10); //有参构造
	Person p3 = Person(p2);//显示法拷贝构造
	//Person(10)单独写就是匿名对象  当前行结束之后，马上析		构,如果这一行后面有代码的话，会出现的情况是，这一行执行然后立马析构销毁，然后执行其下一行代码。
	
	//注意2：不能利用 拷贝构造函数 初始化匿名对象 编译器认为是对象声明，即：Person（p3）等价于 Person p3;
	//Person(p3);

	//2.3 隐式转换法
	Person p4 = 10; // 相当于Person p4 = Person(10); 
	Person p5 = p4; // Person p5 = Person(p4); 
	//Person p5(p4);
}

int main() {
    
    

	test01();
	//test02();
	system("pause");
	return 0;
}

3.3 拷贝构造函数调用时机

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

  • 当用类的一个对象去初始化该类的另一个对象（或引用）时系统自动调用拷贝构造函数实现拷贝赋值。
  • 若函数的形参为类对象，调用函数时，实参赋值给形参，系统自动调用拷贝构造函数。（这里可有可能被编译器优化）
  • 当函数的返回值是类对象时，系统自动调用拷贝构造函数。（注意会有编译器可能会进行优化，而观察不到拷贝的发生）
#include<iostream>
using namespace std;

class Person
{
    
    
public:
	Person()
	{
    
    
		cout << "Person的默认构造函数调用" << endl;
	}
	Person(int a)
	{
    
    
		age = a; 
		cout << "Person的有参构造函数的调用" << endl;
	}
	Person(const Person &p)
	{
    
    
		age = p.age;
		cout << "拷贝构造函数的调用" << endl;
	}
	~Person()
	{
    
    
		cout << "Person的析构函数调用" << endl;
	}

	int age;
};

//当用类的一个对象去初始化该类的另一个对象（或引用）时系统自动调用拷贝构造函数实现拷贝赋值。
void test01()
{
    
    
	Person p1(20);
	Person p2(p1);

	cout << "p2的年龄为：" << p2.age << endl;
}
//2、若函数的形参为类对象，调用函数时，实参赋值给形参，系统自动调用拷贝构造函数。（这里可有可能被编译器优化）
void doWork(Person p)
{
    
    

}
void test02()
{
    
    
	Person p;
	doWork(p); 
}
//3、当函数的返回值是类对象时，系统自动调用拷贝构造函数。（注意会有编译器可能会进行优化，而观察不到拷贝的发生）
Person doWork2()
{
    
    
	Person p1;
	cout << (int*)&p1 << endl;
	return p1;
}
void test03()
{
    
    
	Person p = doWork2();
	cout << (int*)&p << endl;
}
int main()
{
    
    
	test03();
	system("pause");
	return 0;
}

3.4 初始化列表

作用：

C++提供了初始化列表语法，用来初始化属性

语法：构造函数()：属性1(值1),属性2（值2）... {}

  • 传统初始化操作
#include<iostream>
using namespace std;

class Person 
{
    
    
public:

	//传统方式初始化
	Person(int a, int b, int c) 
	{
    
    
		m_A = a;
		m_B = b;
		m_C = c;
	}
	
	int m_A;
	int m_B;
	int m_C;

};

void test01()
{
    
    
	Person p(10, 20, 30);
	cout << "m_A = " << p.m_A << " m_B = " << p.m_B << " m_C = " << p.m_C << endl;
}

int main()
{
    
    
	test01();

	system("pause");

	return 0;
}
  • 初始化列表方式初始化
#include<iostream>
using namespace std;

class Person 
{
    
    
public:

	//2、初始化列表方式初始化
	Person(int a, int b, int c) :m_A(a), m_B(b), m_C(c)
	{
    
    
	}
	int m_A;
	int m_B;
	int m_C;
};
void test02()
{
    
    
	Person p(10, 20, 30);
	cout << "m_A = " << p.m_A << " m_B = " << p.m_B << " m_C = " << p.m_C << endl;
}
int main()
{
    
    
	test02();
	system("pause");
	return 0;
}

总结

期待大家和我交流，留言或者私信，一起学习，一起进步！

猜你喜欢

转载自blog.csdn.net/CltCj/article/details/120896147
今日推荐
《美国对全球网络空间安全与发展的威胁和破坏》报告发布
火速冲上 GitHub 热榜 —— 开源编程语言、框架哪有这么可爱？
北京人形机器人创新中心发布全球首个纯电驱拟人奔跑的全尺寸人形机器人“天工”
LFOSSA 源来如此公开课 | 掌握云原生未来：CNCF 认证全面攻略与备考秘籍
周排行
让自己的头脑极度开放
CentOS 6.5(x64) 和Redhat6.5操作系误删libc
高可用注册中心
【日记】12.28/【题解】AtCoder AGC041
XML（5）_XML 约束_DTD
Java集合Map（四）
树梅派安装桌面环境教程
pipenv 的 使用和安装
小程序白屏问题和内存研究
C语言简单选择排序
每日归档
更多
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)
2024-04-28(0)
2024-04-27(56)
2024-04-26(39)
2024-04-25(22)
2024-04-24(36)
2024-04-23(26)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022