【C++基础】类和对象（重要知识点）封装；静态成员；构造和析构；this指针；友元friend；继承，多态

Melon西西

已于 2023-02-13 21:10:05 修改

阅读量679

点赞数 41

分类专栏：【C/C++要打好基础啊】文章标签： c++ 开发语言

于 2023-01-30 14:27:16 首次发布

本文链接：https://blog.csdn.net/catherine_77/article/details/128788157

版权

【C/C++要打好基础啊】专栏收录该内容

19 篇文章 2 订阅

订阅专栏

🍉内容专栏：【C/C++要打好基础啊】

🍉本文脉络：封装;静态成员;构造和析构;C++对象模型和this指针 ;友元friend;继承;多态

🍉本文作者：Melon西西

🍉发布时间：2023.1.30

1.面向过程和面向对象的认识：

1.1. C++兼容C结构体的用法，同时struct在C++中也升级成了类

面向过程关注把实际问题转化为代码执行的方法

面向对象关注的是类对象及类对象间的关系

Fruit叫做类；f1,f2叫做对象

1.2.给成员变量初始化和打印：(后面4.5有优化)

注意，用成员方法初始化，char形前面必须有const修饰，形参必须为const char *，int不用。

初始化时，char形字符串要用strcpy，int 直接赋值，记住喽！！！

strcpy和strcpy_s需要包含头文件#include<cstring>

在编译的时候如果报错说strcpy不安全C4996，则用strcpy_s（_a,a）拷贝用法一样。

打印成员函数：

2.封装：

数据和方法都放到了一起在类里面，封装是一种更好的管理

面向对象三个特性：封装、继承、多态

2.1.访问限定符

public 共有，可以直接访问

protected 保护，不可以直接访问

private 私有，不可以直接访问

class的默认访问权限为privte

struct的默认访问权限为public（这也是二者的区别）

建议在定义类的时候要明确定义访问限定符，不要用默认的

用法如下：

作用范围：到下一个访问限定符，没有就默认到类结束

注意：善用类域对成员方法（成员函数）进行操作

3.静态成员：及再成员变量和成员函数前加上关键字static

静态成员变量：所有对象共享同一份数据，在编译阶段分配内存，类内声明，类外初始化。

静态成员函数：所有对象共享同一个函数；静态成员函数只能访问静态成员变量，不可访问非静态成员变量。它也是有访问权限的。

Person()
{
public:
    static int _A;   //类内声明
};
int _A = 100;        //类外初始化
void test()
{
  Person p ;
  cout<<p._A<<endl;    //结果是100
  Person p2 ;
  p2._A =200;
  cout<<p._a<<endl;    //这里输出的还是_A，但结果是200，共享一份数据
}

静态成员变量不属于某个对象，因为所有对象都共享同一份数据。它也是有访问权限的。

静态成员变量有两种访问方式：

通过对象进行访问： cout<< _A <<endl;

通过类名进行访问： cout<< Person :: _A <<endl;

4.类的六个默认成员函数

如果我们不实现，编译器会自己生成

4.1构造函数：

构造函数不是开空间创建对象，二十初始化对象。

构造函数不能有返回值，不用写void；

函数名与类名相同；构造函数可以有参数，可以发生重载；

在创建对象的时候构造函数会自动调用，而且只会调用一次。

4.2析构函数~：完成对象中资源的清理

类对象需要资源的清理（开辟了动态资源）才需要自己写析构函数，其他的不用自己实现析构函数。

析构函数名实在类名前面加上字符~

析构函数没有参数没有返回值；

一个类有且只有一个析构函数。

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

如果上述没有写在test1而是写在main函数中

那么析构函数会return 0 后在按任意键后面闪一下子

如果 d1比d2先构造，但是d2比d1先析构

4.3拷贝构造

浅拷贝：编译器提供的拷贝，比如等号赋值。如下；p1和p2年龄都是18，浅拷贝。

浅拷贝可能带来的问题是堆区的内存重复释放，这个问题要利用深拷贝进行释放。

深拷贝：在堆区重新申请空间，进行拷贝操作

参数必须是引用，否则造成无限递归。

4.4函数名operator操作符

函数名算子操作符，返回类型看操作符运算后返回值是什么

操作符有几个操作数，他就有几个参数

返回类型看操作符运算后返回值是什么//参数，操作符有几个操作数，他就有几个参数

如果对两个类进行加减比大小等操作，就需要用运算符重载。

比较两个结构体日期大小：

4.5初始化列表初始化属性

Person (int a,int b, int c) : m_A(a，m_B(b)，m_C(c) 
{
}
test()
{
    Person p (10,20,30);
}

4.6类对象作为成员

C++类中的成员可以是另一个类的对象，我们程该成员为对象成员

在下面代码中，Phone类在Person类中；当其他类对象作为本类对象，先构造其他类对象，再构造自身，及先构造Phone，再构造Person

析构的时候先释放（析构）Person，再析构phone
class Person
{
Public:
       //Phone _Pname =Pname
       Person(int age，string Pname) : _age(age) ,_Pname(Pname)  //初始化列表的方式赋值
       {
       }
       int _age;
       Phone _Phone;
} ;
class Phone
{
public:
       Phone(string Pname)
       {
        _Pname=Pname
       }
       string _Pname;
}  ;
void test1（）
{
  Person p(10,"vivo" );
}

5.C++对象模型和this指针

在C++中，类内的成员变量和成员函数分开存储，只有非静态成员变量才属于类的对象上

空对象占空间内存为1，sizeof(p)=1

此时p占空间内存为4，sizeof(p)=4，后两个不属于类的对象上。

this指针指向被调用的成员函数所指的对象

this指针是隐含在每一个非静态成员函数内的一种指针，不需要定义，直接使用。

在Print（）函数中，（）里隐藏了this指针，类型是Fruit * this

f1.Print（）中，（）里隐藏了&f1
struct Fruit
{
	char _name[20];
	int _number;
	char _colour[20];

	void Init(const char * name, int  number, const char * colour)
	{
		strcpy_s (_name, name);
		_number =  number;
		strcpy_s (_colour, colour);
	}
	void Print()
	{
		cout << _name << _number << _colour << endl;
	}
};
void fruit()
{
	struct Fruit f1;  //兼容C
	Fruit f2;         //升级到类
	f1.Init("苹果", 10, "红色");
	f2.Init("香蕉", 6, "黄色");
}
this指针代表了当前对象，能够区分每个对象的自身数据,保证每个对象拥有自己的数据成员，但共享处理这些数据的代码。

this指针是非静态成员函数的隐含形参，每个非静态的成员函数都有一个this指针。

this指针在非静态的成员函数里面，对象不存在，this指针可以为空。

用途：当形参和成员变量同名时，可用this指针来区分。

在类的非静态成员函数中返回对象本身，可使用return *this

练习：

编译器报错是语法错误，空指针不会编译报错，对空指针解引用会运行崩溃。

6.友元：friend 的三种实现：

6.1.全局函数作为友元

void goodGay()函数为全局函数，只需要把函数复制到类里面，前面加friend即可，不需要放public里

6.2.类做友元：

核心： friend class Goodboy;

#include<iostream>
using namespace std;
class Building
{
	//这样Goodboy就可以访问Building（本类）里的私有成员了
	friend class Goodboy;
public:
	Building();

	string _Sittingroom;
private:
	string _Bedroom;
};
class Goodboy
{
public:
	Goodboy()
	{   //这里注意Building类一定要在Goodboy的上面，不然找不到Building
		building = new Building; 
	}
	Building * building;
	void visit()
	{
		cout << "访问" << building->_Sittingroom << endl;
		//卧室是类的私有成员，不可以访问，加友元后才可以访问
		cout << "访问" << building->_Bedroom <<endl;
	}
};
//放在类外写函数的写法：
Building::Building()
{
	_Sittingroom = "客厅";
	_Bedroom = "卧室";
}
int main()
{
	Goodboy ming;
	ming.visit();
	return 0;
}