C++初步之核心编程篇一：类与封装

最新推荐文章于 2024-11-02 16:10:25 发布

@Aurora,

最新推荐文章于 2024-11-02 16:10:25 发布

阅读量178

点赞数 1

分类专栏： C++初步文章标签： c++ 面向对象编程类和对象封装

本文链接：https://blog.csdn.net/qq_51340322/article/details/120128710

版权

C++初步专栏收录该内容

6 篇文章 0 订阅

订阅专栏

C++初步之核心编程篇一：类与封装

文章目录

C++初步之核心编程篇一：类与封装
内容目录：

内容目录：

00 封装的意义

将属性和行为作为一个整体表现生活中的事物
将属性和行为写在一起来表现事物

01 访问权限

权限类型	-	-	-	-
公共权限	pubilc	成员	类内可访问	类外可访问
保护权限	protected	成员	类内可访问	子类可访问
私有权限	private	成员	类内可访问	子类不可访问

总结：

无论是什么权限，在类内均可访问
公共、保护和私有权限在权限等级上呈增强趋势
保护和私有权限内容在类外不可访问

02 struct与class的区别

struct和class其实基本相同，只是默认权限不同

struct 默认权限为公有 public

class 默认权限为私有 private

03 初始设计案例

设计立方体类

class Cube
{
public:
	void Init(int length, int width, int hight)
	{
	    m_length = length;
		m_width  = width;
		m_hight  = hight;
	}
	long long Volume()//立方体的体积
	{
		long long volume = m_length * m_width * m_hight;
		return volume;
	}
	long long Perimeter()//立方体的周长
	{
		long long perimeter = (m_length + m_width + m_hight) * 4;
		return perimeter;
	}
private:
	int m_length, m_width, m_hight; 
};

设计一个点和圆的关系类

class PointAndCircle
{
public:
	void Init(int point_x, int point_y, int c_x, int c_y, int c_r)
	{
	    this->point_x = point_x;//这里形参名和类内变量名相同时，需要用this指针区别一下
		this->point_y = point_y;
		this->c_x = c_x;
		this->c_y = c_y;
		this->c_r = c_r; 
	}
	void Distance()
	{
		double temp = pow(point_x - c_x, 2) + (point_y - c_y, 2);
		dist = sqrt(temp);
	}
	void Check()
	{
		Distance();
		if (dist > c_r) cout << "点在圆外" << '\n';
		else if (dist == c_r) cout << "点在圆上" << '\n';
		else cout << "点在圆内" << '\n';
	}
private:
	int point_x, point_y, c_x, c_y, c_r;
	double dist; 
};

04 构造、析构函数

1. 构造函数

构造函数：构造函数是一种特殊的函数，用来在对象实例化时初始化对象的成员变量

构造函数的特征
1. 形式为：类名(){}
2. 构造函数：没有返回值，且不写void
3. 函数名与类名相同，(与1.)印证
4. 构造函数可以有参数，因此可以发生重载
5. 程序在调用对象时会自动调用构造，无需手动
构造函数的分类

构造函数可分为有参构造函数和无参(默认)构造函数
拷贝构造函数

拷贝函数的特点：

拷贝构造函数是一种特殊的构造函数，函数的名称必须和类名称一致，它必须的一个参数是本类型的一个引用变量。

形如：Cube (const Cube & a)

拷贝函数的调用时机：
1. 使用一个已经创建完毕的对象
2. 以值传递的方式给参数传值
3. 值返回局部对象
关于深浅拷贝：

简单解释一下：浅拷贝会带来堆区内存的重复释放的问题，需要用到深拷贝来解决(需要自己构造拷贝构造函数)，所以说如果成员有堆区的，一定要自己提供拷贝构造函数，否则拷贝的时候，就会把地址拷贝过来，这两个成员共用一块地址，一方改动，另一方也会跟着动，并且一方将自己内存释放后，另一方就不能再访问了。
构造函数的调用

以Cube类为例
1. 括号法
  
  1 默认(无参)构造函数：Cube c1;
  
  2 有参构造函数：参数不同，调用不同，例如：
  
  构造函数为：Cube(int a, int b) {}，调用如Cube c2(10, 20)形式
  
  3 拷贝构造函数：Cube c3(c2);
2. 显式法
  
  Cube c2 = Cube(10, 20);其中Cube(10, 20)是一个匿名对象
3. 隐式转化法
  
  有参构造：Cube c4 = {10, 20};//老版C++标准不可以这样做
  
  拷贝构造：Cube c5 = c4;

2. 析构函数

析构函数：析构函数（方法）作用和构造方法正好相反，是对象被销毁之前最后一个被对象自动调用的方法

形式为：~Cube(){}

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

析构函数函数名与类名相同，在名称前加上~

析构函数无参，不能发生重载

程序在对象销毁前会自动调用析构，无需手动

05 初始化列表

方法一：

class Cube
{
public:
    Cube(int a, int b, int c)
    {
        m_a = a;
        m_b = b;
        m_c = c;
    }
    int m_a, m_b, m_c;
};

方法二：

class Cube
{
public:
    int m_a, m_b, m_c;
    Cube() : m_a(10), m_b(20), m_c(30){}
};

方法三：

class Cube
{
public:
    int m_a, m_b, m_c;
    Cube (int a, int b, int c) : m_a(a), m_b(b), m_c(c){}
};

06 类对象作为类成员

class A {};

class B
{
    A a;
}

当其他类对象作为本类成员，构造时先构造对象，再构造自身，析构的顺序与构造相反

07 静态成员、函数

静态成员、函数的特点
1. 不可访问非静态变量
2. 所有函数共享
3. 有public和private权限
静态成员、函数两种访问方式

1). 通过对象访问：Cube c; c.func();

2). 通过类名访问：Cube::func();

只有非静态成员才属于类的对象，静态成员函数不属于类

注意：

空类的大小为1

class Cube
{
    
};
//Cube c; sizeof(c)为1

一旦类不为空，大小就为非静态变量所占内存(变量全为同一类型不考虑内存对齐)
```
class Cube
{
    int m_a, m_b, m_c;
};
//Cube c; sizeof(c)为12,在int为4字节的情况下
```
内存对齐就不一样了，具体内容请看内存对齐

当类内出现很多不同类型的变量时，有内存对齐操作，使得
```
class Cube
{
    int m_a, m_b, m_c;
    
    double m_x;
};

Cube c;
```
中sizeof© ${\neq}$ 20，而sizeof© $KaTeX parse error: Undefined control sequence: \eq at position 2: {\̲e̲q̲}$ 24

08 this指针与空指针调用成员函数

this指针简介

类内的成员函数内置了this指针，this就是本类的意思

this->m_a，即为类内成员m_a，this->func()，即为类内成员函数func

this指针的作用

解决名称冲突

如：

class Cube
{
public:
    Cube(int m_a)//构造函数
    {
        m_a = m_a;
    }
    int m_a, m_b;
};

这样写，类内的m_a的值并没有改变，这两个m_a都是一样的局部变量，需要这样写才行：

class Cube
{
public:
    Cube(int m_a)//构造函数
    {
        this->m_a = m_a;
    }
    int m_a, m_b;
};

这样就能做一个很好地区分。

返回对象本身(链式编程思想)：返回值为引用，具体内容，this指针返回引用

class Cube
{
public:
    Cube(int m_a)//构造函数
    {
        this->m_a = m_a;
    }
    Cube& set_m_a(int a)
    {
        m_a = a;
        return *this;
    }
    int m_a, m_b;
};

空指针访问成员函数

空指针由于未分配内存，所以空指针不能访问类中的变量，只可访问部分成员函数，该部分成员函数需要满足：不访问类内成员这一条件。
```
class Cube
{
    int m_a, m_b;
public:  
    void showName()
    {
        cout << "zhangsan" << '\n';
    }
};

Cube *c = NULL;

c->showName();//可以运行
```

09 常函数与常对象

1. 常函数

用const修饰的成员函数称为常函数

在常函数中，不能修改成员属性，如果非要修改，则将成员属性声明时加关键字mutable后可修改

void showName() const//this指向的值不可修改
{
    
}

用mutable int m_a;即可在常函数内完成修改

2. 常对象

在类前加const修饰的对象称为常对象

const Cube c;

常对象中，无论是在类内函数中还是在类外函数所有变量都不可修改，而且在类内函数中无法访问变量，只能在类外访问

10 友元

友元的三种方式

全局函数做友元

全局函数写在类外，无法访问类中私有部分，需要将函数声明写入类中，前面用friend修饰

#include <iostream>
#include <cstdlib>

using namespace std;

class A
{
    int m_a;
public:  
    A(int a) : m_a(a) {};
    friend void func(A *a_point);
};

void func(A *a_point)//全局函数做友元
{
    cout << a_point->m_a << '\n';
}

int main()
{
	A * a_point = new A(10);
	
	func(a_point);
	
	return 0;
}

全局函数做友元实现全局函数对类内所有属性成员的访问。

类做友元

#include <iostream>
#include <cstdlib>

using namespace std;

class B;

class A
{
public:
    void func();
    B *b_point;
};

class B
{
public:
	friend class A;//类做友元
	B()//B类的构造函数
	{
		name = "zhangsan";
		num = 18;
    }
private:
    string name;
    int num;
};



void A::func()
{
	b_point = new B;
    cout << b_point->name << ' ' << b_point->num << '\n';
}

int main()
{
	A a;
	a.func();
	
	return 0;
}

类做友元实现对另一个类所有属性成员的访问。

成员函数做友元

#include <iostream>
#include <cstdlib>

using namespace std;

class B;

class A
{
public:
    void func();
    B *b_point;
};

class B
{
public:
    friend void A::func();//成员函数做友元
    B()//B类的构造函数
	{
		name = "zhangsan";
		num = 18;
        sex = 'M';
    }
    string name;
    int num;
private:
    char sex;
};

void A::func()
{
    b_point = new B;
    cout << b_point->name << ' ' << b_point->sex << '\n';
}

int main()
{
	A a;
	a.func();
	
	return 0;
}