史上最全 C++核心编程

已于 2022-11-21 16:30:04 修改
阅读量1.3k 收藏 2
点赞数
分类专栏： C++学习 文章标签： c++ 开发语言 算法
于 2022-11-15 18:00:23 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40626928/article/details/127696939
版权
本文深入探讨C++的核心编程技术，包括内存分区模型、引用、函数提高、类和对象的详细使用，如封装、继承、多态，以及文件操作。通过对C++中的构造函数、析构函数、函数重载、成员函数、友元、运算符重载、继承和多态等概念的讲解，旨在提升读者对C++面向对象编程的理解和应用能力。
摘要由CSDN通过智能技术生成

文章目录

C++核心编程

本阶段主要针对C++面向对象编程技术做详细讲解，探讨C++中的核心和精髓。

1 内存分区模型

C++程序执行时，将内存大方向划分为4个区域

  • 代码区：存放函数的二进制代码，由操作系统进行管理
  • 全局区：存放全局变量和静态变量以及常量
  • 栈区：由编译器自动分配释放，存放函数的参数值，局部变量等
  • 堆区：由程序员分配和释放，若程序员不释放，程序结束时由操作系统回收

内存四区意义：
不同区域存放的数据，赋予不同生命周期，给我们更大的灵活编程。

1.1 程序运行前

在程序编译后，生成了exe可执行文件，未执行该程序前分为两个区域：
代码区：
存放CPU执行的机器指令
代码区是共享的，共享的目的是对于频繁被执行的程序，只需要在内存中有一份代码即可
代码区是只读的，使其只读的原因是防止程序意外地修改了它的指令
全局区：
全局变量和静态变量存放在此。
全局区还包含了常量区，字符串常量和其它常量也存放在此。
该区域的数据在程序结束后由操作系统释放。
在这里插入图片描述

1.2 程序运行后

栈区：
由编译器自动分配释放，存放函数的参数值，局部变量等。
注意事项：不要返回局部变量的地址，栈区开辟的数据有编译器自动释放。
示例：

#include<iostream>
using namespace std;

//栈区注意事项 --不要返回局部变量的地址
//栈区的数据有编译器管理开辟和释放

int* func(int b)  //形参数据也会放在栈区
{
   
	b = 100;
	int a = 10;  //局部变量  存放在栈区，栈区的数据在函数执行完后自动释放
	return &a;   //返回局部变量的地址
}

int main()
{
   
	//接受func函数的返回值
	int* p = func(100);

	cout << *p << endl;
	cout << *p << endl;
	cout << *p << endl;

	system("pause");
	cout << endl;
}

1.3 new操作符

C++中利用new操作符在堆区开辟数据
堆区开辟的数据，有程序员手动开辟，手动释放，释放利用操作符delete
语法：new 数据类型
利用new创建的数据，会返回该数据对应的类型的指针
示例：

#include<iostream>
using namespace std;

//1、new的基本语法
int* func()
{
   
	//在堆区创建整型数据
	//new返回是该数据类型的指针
	int * p = new int(10);
	return p;
}

void test01()
{
   
	int* p = func();
	cout << *p << endl;
	cout << *p << endl;
	cout << *p << endl;
	cout << *p << endl;
	//堆区的数据由程序员管理开辟，管理员管理释放
	//如果想释放堆区的数据，利用关键字delete
	delete p;
	//cout << *p << endl;    //内存已经被释放，再次访问就是非法操作，会报错
}

//2、在堆区利用new开辟数组
void test02()
{
   
	//创建10整型数据的数组，在堆区
	int* arr = new int[10]; //10代表数组有10个元素，返回数组首地址

	for (int i = 0; i < 10; i++)
	{
   
		arr[i] = i + 100; //给10个元素赋值100~109 利用指针arr也可以利用中括号的形式去索引每个数据
	}

	for (int i = 0; i < 10; i++)
	{
   
		cout << arr[i] << endl;
	}
	//释放堆区数组
	//释放数组的时候，要加入[]才可以
	delete[] arr;
	/*      //释放完之后堆区内存就无法操作了
	for (int i = 0; i < 10; i++)
	{
		cout << arr[i] << endl;
	}
	*/
}

int main()
{
   
	test01();

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

2 引用

2.1 引用的基本使用

**作用：**给变量起别名
**语法：**数据类型 &别名 = 原名
示例：
在这里插入图片描述

2.2 引用注意事项

2.3 引用做函数参数

作用：函数传参时，可以利用引用的技术让形参修饰实参
优点：可以简化指针修改实参
示例：

#include<iostream>
using namespace std;

//交换函数 
	//1、值传递
void mySwap01(int a, int b)
{
   
	int temp = a;
	a = b;
	b = temp; 

	cout << "swap01 a = " << a << endl;
	cout << "swap01 b = " << b << endl;
}
	//2、地址传递
void mySwap02(int *a, int *b)
{
   
	int temp = *a;
	*a = *b;
	*b = temp;
}
	//3、引用传递
void mySwap03(int &a, int &b)
{
   
	int temp = a;
	a = b;
	b = temp;

	//cout << "swap03 a = " << a << endl;
	//cout << "swap03 b = " << b << endl;
}

int main()
{
   
	int a = 10;
	int b = 20;

	mySwap01(a, b); //值传递，形参不会修饰实参
	cout << " a = " << a << endl;
	cout << " b = " << b << endl;

	//mySwap02(&a, &b); //地址传递，形参会修饰实参的

	//cout << " a = " << a << endl;
	//cout << " b = " << b << endl;

	mySwap03(a, b);
	cout << " a = " << a << endl;
	cout << " b = " << b << endl;

	system("pause");
	cout << endl;
}

2.4 引用做函数返回值

作用：引用时可以作为函数的返回值存在的
注意：不要返回局部变量引用
用法：函数调用作为左值
示例：

#include<iostream>
using namespace std;

//引用做函数的返回值
//返回局部变量引用
int& test01()  //以引用的方式作为返回
{
   
	int a = 10; //局部变量 存放在四区中的栈区 函数执行完，释放
	return a;
}

//2、函数的调用可以作为左值

//返回静态变量引用
int& test02()
{
   
	static int a = 20; //静态变量，存放在全局区，全局区上的数据在整个程序结束后由系统释放
	return a;
}

int main()
{
   
	int& ref = test01();
	
	cout << "ref = " << ref << endl;  //第一次结果正确，是因为编译器做了保留
	cout << "ref = " << ref << endl;	//第二次结果错误，因为a的内存已经释放

	int& ref2 = test02();
	cout << "ref2 = " << ref2 << endl;  //第一次结果正确，是因为编译器做了保留
	cout << "ref2 = " << ref2 << endl;	//第二次结果错误，因为a的内存已经释放

	test02() = 1000;   //如果函数的返回值是引用，这个函数调用可以作为左值
	cout << "ref2 = " << ref2 << endl;  //第一次结果正确，是因为编译器做了保留
	cout << "ref2 = " << ref2 << endl;	//第二次结果错误，因为a的内存已经释放

	system("pause");
	return 0;
	cout << endl;
}

2.5 引用的本质

本质: 引用的本质在c++内部实现是一个指针常量
讲解示例：
在这里插入图片描述

#include<iostream>
using namespace std;

//引用的本质就是一个指针常量
//引用一旦初始化后，就不可发生改变

//发现是引用，转换为int* const ref = &a;
void func(int& ref)
{
   
	ref = 100; //ref是引用，转换为*ref = 100
}
int main()
{
   
	int a = 10;
	//自动转换为 int * const ref = &a; 指针常量是指针指向不可改，也说明为什么引用不可更改
	int& ref = a;
	ref = 20; //内部发现ref是引用，自动帮我们转换为：*ref = 20;

	cout << "a:" << a << endl;
	cout << "ref:" << ref << endl;

	func(a);
	
	system("pause");
	return 0;
	cout << endl;
}

2.6 常量引用

作用：常量引用主要用来修饰形参，防止误操作
在函数形参列表中，可以加const修饰形参，防止形参改变实参
示例：

#include<iostream>
using namespace std;

//打印数据函数
void showValue(const int& val) //加const为了防止误操作
{
   
	//val = 1000;
	cout << "val = " << val << endl;
}

int main()
{
   
	//常量引用
	//使用场景：用来修饰形参，防止误操作

	// int a = 10;
	// int& ref = 10;  //引用必须引一块合法的内存空间，在栈或堆取数据

	 //加上const之后，编译器将代码修改 int temp = 10; const int & ref = temp;
	// const int& ref = 10; 

	// ref = 20;  //加入const之后变为只读，不可以修改

	int a = 100;
	showValue(a);

	 system("pause");
	 return 0;
}

3 函数提高

3.1 函数默认参数

  • 如果某个位置已经有了默认参数，那么从这个位置往后，从左到右都必须有默认值
  • 如果函数声明有默认值，函数实现的时候就不能有默认参数
#include<iostream>
using namespace std;

//函数默认参数

//如果我们自己传入数据，就用自己的数据，如果没有，那么就用默认值
//语法：返回值类型 函数名（形参 = 默认值）{}

int func(int a, int b = 20, int c = 30)
{
   
	return a + b + c;
}

//注意事项
//1、如果某个位置已经有了默认参数，那么从这个位置往后，从左到右都必须有默认值
//int func2(int a = 10, int b, int c, int d)
//{
   
//	return a + b + c;
//}

// 2、如果函数声明有默认值，函数实现的时候就不能有默认参数
int func2(int a = 10, int b = 10);
int func2(int a, int b)
{
   
	return a + b;
}

int main()
{
   
	cout << func(10) << endl;
	system("pause");
	return 0;
}

3.2 函数占位参数

C++中函数的形参列表里可以有占位参数，用来做占位，调用函数时必须填补该位置
语法：返回值类型 函数名 （数据类型）{}
在现阶段函数的占位参数存在意义不大，但是后面的课程中会用到该技术
示例：

#include<iostream>
using namespace std;

//目前阶段的占位参数意义不到，但后续会用到
//函数占位参数，占位参数也可以有默认参数
void func(int a, int)
{
   
	cout << "this is func" << endl;
}

int main()
{
   
	func(10, 10); //占位参数必须填补

	system("pause");
}

3.3 函数重载

3.3.1 函数重载概述

作用：函数名可以相同，提高复用性

函数重载满足条件：

  • 同一个作用域下
  • 函数名称相同
  • 函数参数类型不同或者个数不同或者顺序不同
    注意：函数的返回值不可以作为函数重载的条件
#include<iostream>
using namespace std;

//函数重载
//可以让函数名相同，提高复用性

//函数重载满足的条件
//1、同一个作用域下
//2、函数名称相同
//3、函数参数类型不同，或者个数不同，或者顺序不同

void func()
{
   
	cout << "func的调用" << endl;
}

void func(int a)
{
   
	cout << "func(int a)的调用" << endl;
}

void func(double b)
{
   
	cout << "func(double b)的调用" << endl;
}

void func(int a, double b)
{
   
	cout << "func(int a, double b)的调用" << endl;
}

void func(double a, int b)
{
   
	cout << "func(double a, int b)的调用" << endl;
}
//注意事项
//函数的返回值不可以作为函数重载的条件
//int func(double a, int b)
//{
   
//	cout << "func(double a, int b)的调用" << endl;
//}

int main()
{
   
	func();
	func(10);
	func(3.14);
	func(10, 3.14);
	func(3.14, 10);

	system("pause");
	cout << endl;
}
3.3.2 函数重载注意事项
  • 引用作为重载条件
  • 函数重载碰到函数默认参数
    示例：
#include<iostream>
using namespace std;

//函数重载注意事项
// 1、引用作为重载的条件
void func(int &a)  //int &a = 10 不合法
{
   
	cout << "func(int &a)的调用" << endl;
}

void func(const int& a)  //const int &a = 10; 合法
{
   
	cout << "func(const int &a)调用" << endl;
}

//2、函数重载碰到默认参数
void func2(int a, int b = 10)
{
   
	cout << "func2(int a, int b)的调用" << endl;
}

void func2(int a)
{
   
	cout << "func2(int a)的调用" << endl;
}

int main()
{
   
	//int a = 10;
	//func(a);  //变量可读可写

	func(10);

	//func2(10);  //当函数重载碰到默认参数，出现二义性，报错，尽量避免这种情况

	system("pause");
	cout << endl;
}

4 类和对象

C++面向对象的三大特征为： 封装、继承、多态
C++ 认为万事万物都皆为对象，对象上有其属性和行为

例如：人可以作为对象，属性有姓名、年龄、身高、体重，行为有走、跑、跳
具有相同性质的对象，我们可以抽象称为类，人属于人类，车属于车类

4.1 封装

4.1.1 封装的意义

封装是C++面向对象三大特征之一
封装的意义：

  • 将属性和行为作为一个整体，表现生活中的事物
  • 将属性和行为加以权限控制
    封装意义一：
    在设计的时候，属性和行为写在一起，表现事物
    语法：class 类名{ 访问权限： 属性 / 行为}；
    示例1：设计一个圆类，求圆的周长
    示例代码:
#include<iostream>
using namespace std;

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

//设计学生类
class Student
{
   
public: //公共权限

	//类中的属性和行为 我们统一称为 成员
	//属性  成员属性  成员变量
	//行为  成员函数  成员方法

	//属性
	string m_Name; //姓名
	int m_Id; //学号

	//行为
	//显示姓名和学号
	void showStudent()
	{
   
		cout << "姓名： " << m_Name << "学号：" << m_Id << endl;
	}

	void setName(string name)
	{
   
		m_Name = name;
	}

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

int main()
{
   
	//创建一个具体学生 实例化对象
	Student s1;
	//给s1对象  进行属性赋值和操作
	s1.m_Name = "张三";
	s1.setId (5);
	//显示学生信息
	s1.showStudent();

	Student s2;
	s2.setName("李四");
	s2.m_Id = 2;
	s2.showStudent();

	system("pause");
	cout << endl;
}
4.1.2 struct和class区别

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

  • struct 默认权限为公共
  • class 默认权限为私有
#include <iostream>
using namespace std;

class C1
{
   
	int m_A;  //默认权限   是私有
};

struct C2
{
   
	int m_A;   //默认权限   是公共
};

int main()
{
   
	//struct 和class 区别
	//struct 默认权限是  公共 public
	//class 默认权限是 私有 private
	C1 c1;
	//c1.m_A = 100;  //在class里默认权限 私有 ，因此类外不可以访问

	C2 c2;
	c2.m_A = 100;  //在struct默认的权限为公共，因此可以访问

	system("pause");
}
4.1.3 成员属性设置为私有

优点1：将所有成员属性设置为私有，可以自己控制读写权限
优点2：对于写权限，我们可以检测数据的有效性

#include<iostream>
using namespace std;

//成员属性设置为私有
//1、可以自己控制读写权限
//2、对于写可以检测数据的有效性

//设计人类
class Person
{
   
public:
	
	//设置姓名
	void setName(string name)
	{
   
		m_Name = name;
	}
	//获取姓名
	string getName()
	{
   
		return m_Name;
	}

	//获取年龄  只读
	int getAge()
	{
   
		//m_Age = 0;  //初始化为0岁
		return m_Age;
	}

	//设置年龄
	void setAge(int age)
	{
   
		if (age < 0 || age > 150)
		{
   
			m_Age = 0;
			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(90);
	cout << "年龄为： " << p.getAge() << endl;

	//设置情人为苍井女士
	p.setLover("苍井");
	//cout << "情人为：" << p.setLover() << endl;  //是不可以访问的

	system("pause");
	return 0;
}

封装案例1 - 立方体：

封装案例2-点和圆的关系：

#include<iostream>
using namespace std;

//点和圆关系案例
//点类
class Point
{
   
public:
	//设置x
	void setX(int x)
	{
   
		m_X = x;
	}
	//获取x
	int getX()
	{
   
		return m_X;
	}
	//设置y
	void setY(int y)
	{
   
		m_Y = y;
	}
	//获取y
	int getY()
	{
   
		return m_Y;
	}

private:
	int m_X;
	int m_Y;
};

//圆类
class Circle
{
   
public:
	//设置半径
	void setR(int r)
	{
   
		m_R = r;
	}
	//获取半径
	int getR()
	{
   
		return m_R;
	}
	//设置圆心
	void setCenter(Point center)
	{
   
		m_Center = center;
	}
	//获取圆心
	Point getCenter()
	{
   
		return m_Center;
	}

private:
	int m_R; //半径

	//在类中可以让另外一个类作为本来中的成员
	Point m_Center; //圆心
};


//判断点和圆关系
void isInCircle(Circle& c, Point& p)
{
   
	//计算两点之间的距离 平方
	int distance =
		(c.getCenter().getX() - p.getX()) * (c.getCenter().getX() - p.getX()) +
		(c.getCenter().getY() - p.getY()) * (c.getCenter().getY() - p.getY());

	//计算半径的平方
	int rDistance = c.getR() * c.getR();

	//判断关系
	if (distance == rDistance)
	{
   
		cout << "点在圆上" << endl;
	}
	else if (distance > rDistance)
	{
   
		cout << "点在圆外" << endl;
	}
	else
	{
   
		cout << "点在圆内" << endl;
	}
}

int  main
最低0.47元/天 解锁文章
faithe_mili
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c++核心编程
晓小的博客
03-27 225
一. 内存分区模型 四个分区 代码区：存放函数体二进制代码,由操作系统进行管理 全局区：存放全局变量和静态变量以及常量 栈区：由编译器自动分配和释放，存放函数参数值，局部变量等 堆区：由程序员分配和释放，若程序员不释放，程序结束后由操作系统回收 注意：常量区存放全局常量，和字符串常量 程序运行前 代码区：共享，只读 全局区：程序结束后由操作系统释放 程序运行后 ...
C++核心编程4— 类和对象
果果小师弟的博客
09-20 1102
C++面向对象的三大特性为：封装、继承、多态 C++认为万事万物都皆为对象，对象上有其属性和行为 例如： ​ 人可以作为对象，属性有姓名、年龄、身高、体重…，行为有走、跑、跳、吃饭、唱歌… ​ 车也可以作为对象，属性有轮胎、方向盘、车灯…,行为有载人、放音乐、放空调… ​ 具有相同性质的对象，我们可以抽象称为类，人属于人类，车属于车类 4.1 封装 4.1.1 封装的意义 封装是C++面向对象三大特性之一 封装的意义： 将属性和行为作为一个整体，表现生活中的事物 将属性和行为加以权限控制 封装意义一：
C++核心编程
最新发布
niubilitygeorge的博客
07-04 591
*作用：**函数名可以相同，提高复用性同一个作用域下函数名称相同函数参数类型不同或者个数不同或者顺序不同函数的返回值不可以作为函数重载的条件//函数重载需要函数都在同一个作用域下cout
C++核心编程笔记
随写博客
07-05 1601
C++核心编程笔记
C++-核心编程
yongzhouchen的博客
02-18 342
C++核心编程 本阶段主要针对C++面向对象编程技术做详细讲解，探讨C++中的核心和精髓。 1 内存分区模型 C++程序在执行时，将内存大方向划分为4个区域 代码区：存放函数体的二进制代码，由操作系统进行管理的 全局区：存放全局变量和静态变量以及常量 栈区：由编译器自动分配释放, 存放函数的参数值,局部变量等 堆区：由程序员分配和释放,若程序员不释放,程序结束时由操作系统回收 内存四区意义： 不同区域存放的数据，赋予不同的生命周期, 给我们更大的灵活编程 1.1 程序运行前 ​ 在程序编译后，生成了e.
【李宁】征服C++11（史上最权威C++视频教程）.zip
08-17
《李宁征服C++11：史上最权威C++视频教程》是李宁老师精心打造的一套C++教学资源，旨在帮助学习者深入理解和掌握C++11标准的新特性和编程技巧。通过这套教程，你可以系统地学习C++的基础语法、面向对象编程、模板元...
史上最全的c++材料
10-30
"史上最全的C++材料"这个标题暗示了我们所拥有的资源可能是非常全面的，涵盖了C++学习的各种方面，包括基础概念、语法、高级特性、设计模式以及实际应用。 描述中的“最全”一词意味着这份资料可能包含从入门到精通...
史上最深刻的C++编程思想
04-27
"史上最深刻的C++编程思想"这个主题，旨在深入探讨C++编程中的核心概念和设计原则，这对于提升程序员的技术水平至关重要。编程思想的提升不仅能帮助我们写出更优美的代码，还能提高程序的可读性、可维护性和性能。 ...
史上最全总结Java 基础核心总结【2023最新版大全】
07-06
这份"史上最全总结Java基础核心总结【2023最新版大全】"无疑是学习和复习Java编程的宝贵资源。它涵盖了从基础概念到高级特性的全方位内容，旨在帮助开发者从初学者到专家的进阶之路。 首先，让我们探讨Java的基础...
C++核心编程.pdf
09-05
C++核心编程，主要针对C++==面向对象==编程技术做详细讲解，探讨C++中的核心和精髓。
c++核心编程指南中文版
09-29
c++核心编程指南中文版
C++ 核心编程
既然选择远方，便只顾风雨兼程！
02-14 671
面向对象编程思想 一、 内存分区模型 C++程序在执行时，将内存大方向划分为4个区域 代码区：存放函数体的二进制代码，由操作系统进行管理 全局区：存放全局变量和静态变量以及常量 栈区：由编译器自动分配释放，存放函数的参数值、局部变量等 堆区：由程序员分配和释放，若程序员不释放，程序结束时由操作系统回收 内存四区的意义：不同区域存放的数据，赋予不同的生命周期，给我们更大的灵活编程 1、 程序执行前 在程序编译后，生成了.exe课执行程序，未执行该程序前分为两个区域 代码区 存放CPU执行的机械命令 代码
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值