C++编程学习(二) —— C++进阶编程

已于 2023-06-29 19:26:54 修改
阅读量339 收藏 3
点赞数 1
文章标签： c++ 学习 开发语言
于 2023-06-29 19:06:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_66238629/article/details/131462551
版权
本文详细介绍了C++的内存管理，包括内存分区模型，如代码区、全局区、栈区和堆区，以及new操作符的使用。接着，文章深入探讨了C++中的引用，包括引用的基本操作、注意事项、在函数参数和返回值中的应用。此外，讲解了函数的高级技巧，如默认参数、占位参数和重载。最后，文章重点阐述了类和对象的概念，包括封装、构造函数、析构函数、深拷贝与浅拷贝、静态成员以及友元，同时涵盖了多态的基础和应用场景。通过对C++核心特性的深入解析，帮助读者提升C++编程技能。
摘要由CSDN通过智能技术生成

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

1 内存分区模型

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

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

在程序运行前有代码区和全局区，程序运行后才有栈区和堆区。

内存四区意义：

不同区域存放的数据，赋予不同的生命周期，给我们很大的灵活编程。

1.1 在程序运行前

在程序编译后，生成了exe可执行文件，未执行该程序前分为两个区域：

代码区：

​ 存放CPU执行的机器指令；

​ 代码区时==共享==的，共享的目的是对于频繁被执行的程序，只需要在内存中由一份代码即可；

​ 代码区是==只读==的，使其只读的原因是防止程序意外地修改了它的指令。

全局区：

​ 全局变量和静态变量存放在此；

​ 全局区还包含了常量区，字符串常量和其他常量（也包括const修饰的变量）也存放在此；

​ 该区域的数据在程序结束后由操作系统释放。

总结：

不在全局区中：局部变量、const修饰的局部变量

在全局区中：全局变量、静态变量(static关键字修饰的变量)、常量(字符串常量、const修饰的全局变量(全局常量))

例如：

#include<iostream>
using namespace std;

//全局变量
int g_a = 10;
int g_b = 10;

//const修饰的全局变量，全局常量
const int c_g_a = 10;
const int c_g_b = 10;

int main() {
   
	//全局区
	//全局变量、静态变量、常量
	//静态变量，在普通变量前面加static，属于静态变量
	static int s_a = 10;
	static int s_b = 10;
	//常量：字符串常量
	cout << "字符串常量的地址为：" << (int)&"hello world" << endl;
	//const修饰的变量:const修饰的全局变量、const修饰的局部变量
	//const修饰的全局变量
	cout << "const修饰的全局常量c_g_a的地址为：" << (int)&c_g_a << endl;
	cout << "const修饰的全局常量c_g_b的地址为：" << (int)&c_g_b << endl;

	//const修饰的局部变量
	const int c_l_a = 10; //c-const g-global l-local
	const int c_l_b = 10; //
	cout << "const修饰的局部常量c_l_a的地址为：" << (int)&c_l_a << endl;
	cout << "const修饰的局部常量c_l_b的地址为：" << (int)&c_l_b << endl;

	//创建普通局部变量
	int a = 10;
	int b = 10;

	cout << "局部变量a的地址：" << (int)&a << endl;
	cout << "局部变量b的地址：" << (int)&b << endl;

	cout << "全局变量g_a的地址：" << (int)&g_a << endl;
	cout << "全局变量g_b的地址：" << (int)&g_b << endl;

	cout << "全局变量s_a的地址：" << (int)&s_a << endl;
	cout << "全局变量s_b的地址：" << (int)&s_b << endl;

	system("pause");
	return 0;
}

运行结果：

image-20220128180133418

image-20220128182700919

总结：

  • C++中在程序运行前分为全局区和代码区；
  • 代码区特点是共享和只读；
  • 全局区中存放全局变量、静态变量、常量；
  • 常量区存放const修饰的全局变量(也称全局常量)和字符串常量。

1.2 程序运行后

栈区：

由编译器自动分配释放，存放函数的参数值，局部变量等。

注意事项：不要返回局部变量的地址，栈区开辟的数据由编译器自动释放。

错误示例：下面程序中返回局部变量的地址是错误的，栈区的数据运行后会自动释放。

#include<iostream>
using namespace std;

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

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

	cout << *p << endl;//第一次可以打印正确的数字，是因为编译器做了保留
	cout << *p << endl;//第二次这个数据就不再保留(在32位运行环境中)

	system("pause");
	return 0;
}

堆区：

由程序员分配释放，若程序员不释放，程序结束时由操作系统回收

在C++中主要利用new在堆区开辟内存

示例：

#include<iostream>
using namespace std;

int* func() {
   
	//利用new关键字可以将数据开辟到堆区，下面的代码将10存放到堆区，将10的地址作为栈区中指针变量p的值
	int* p = new int(10);//这里的指针本质也是局部变量，放在栈上，指针保存的数据是放在堆区
	return p;
}

int main() {
   
	//在堆区开辟数据
	int* p = func(); 
	cout << *p << endl;//

	system("pause");
	return 0;
}

总结：

​ 堆区数据由程序员管理开辟和释放。

​ 堆区数据利用new关键字进行开辟内存

1.3 new操作符

C++中利用new操作符在堆区开辟数据

堆区开辟的数据，由程序员手动开辟，手动释放，释放利用操作符delete

语法：new 数据类型

利用new创建的数据，会返回该数据对应的类型的指针。

示例：基本语法

#include<iostream>
using namespace std;

int* func() {
   
	//在堆区创建整型数据
	//new返回的是该数据类型的指针
	int* p = new int(10);//double* p = new double(6.23);//如果是double类型这样写。
	return p;
}

void test01() {
   
	int* p = func();
	cout << *p << endl;
	delete p;//释放数据的地址
	//cout << *p << endl;//不能用这句命令，由于*p的地址已经释放，没有权限访问
}

void test02() {
   
	//创建10整型数据的数组，在堆区
	int* arr = new int[10];//
	for (int i = 0; i < 10; i++) {
   
		arr[i] = i + 100;//给10个元素赋值 100~109
	}
	for (int i = 0; i < 10; i++) {
   
		cout << arr[i] << endl;
	}

	//释放堆区数据
	//释放数组的时候，要加[]才可以
	delete[] arr;
}

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

	system("pause");
	return 0;
}

2 引用

2.1 引用的基本操作

作用：给变量起别名

语法：数据类型 &别名 = 原名

示例：

#include<iostream>
using namespace std;

int main() {
   
	int a = 10;
    //引用基本语法
	//数据类型 &别名 = 原名
	int& b = a;
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;

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

	system("pause");
	return 0;
}

2.2 引用注意事项

  • 引用必须初始化
  • 引用在初始化后，不可以改变

示例：

#include<iostream>
using namespace std;

int main() {
   
	
	int a = 10;
	int c = 20;
	//数据类型 &别名 = 原名
	int& b = a;
	//int& b;//这一行是错误的，引用必须初始化
	//int& b = c;//这一行是错误的，此时的b已经初始化为a的别名，不能更改

	b = c;//赋值操作，而不是引用

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

	b = 100;
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	cout << "c = " << c << endl;

	system("pause");
	return 0;
}

2.3 引用做函数参数

作用：函数传参时，可以利用引用的技术让形参修饰实参

优点：可以简化指针修改实参

示例：

#include<iostream>
using namespace std;

//值传递，形参不会修饰实参（形参无法改变实参）
void swap01(int a, int b) {
   
	int temp = a;
	a = b;
	b = temp;
}

//地址传递，形参会修饰实参
void swap02(int* a, int* b) {
   
	int temp = *a;
	*a = *b;
	*b = temp;
}

//引用传递，形参会修饰实参
void swap03(int& a, int& b) {
   //利用引用，对引用的操作即是对原始数据的操作
	int temp = a;
	a = b;
	b = temp;
}

int main() {
   
	
	int a = 10;
	int b = 20;
	
	swap01(a, b);
	cout << "swap01 a = " << a << endl;
	cout << "swap01 b = " << b << endl;

	a = 10;
	b = 20;
	swap02(&a, &b);
	cout << "swap02 a = " << a << endl;
	cout << "swap02 b = " << b << endl;
	
	a = 10;
	b = 20;
	swap03(a, b);
	cout << "swap03 a = " << a << endl;
	cout << "swap03 b = " << b << endl;

	system("pause");
	return 0;
}

总结：通过引用参数产生的效果同按地址传递是一样的。引用的语法更加清楚简单。

2.4 引用做函数返回值

作用：引用是可以作为函数的返回值存在的。

注意：不要返回局部变量引用

用法：函数调用作为左值

示例：

#include<iostream>
using namespace std;

int& test01() {
   
	int a = 10;//局部变量存放在四区中的栈区
	return a;//不要返回局部变量的引用，这里的代码是错误的
}

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

int main() {
   
	//引用做函数的返回值
	
	//函数的调用可以作为左值
	/*
	int& ref = test01();
	cout << "ref = " << ref << endl;//第一次结果正确，是因为编译器做了保留
	cout << "ref = " << ref << endl;//第二次结果错误，因为a的内存已经释放（32位编译环境）
	*/
	int& ref2 = test02();//这里的代码是
	cout << "ref2 = " << ref2 << endl;
	test02() = 1000;//如果函数的返回值是引用，这个函数的调用可以作为左值
	cout << "ref2 = " << ref2 << endl;

	system("pause");
	return 0;
}

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 = 20;

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

	system("pause");
	return 0;
}

总结：C++推荐用引用技术，因为语法方便，引用本质是指针常量，但是所有的指针操作编译器都帮我们做了。

2.6 常量引用

作用：常量引用主要用来修饰形参，防止误操作

在函数形参列表中，可以加const修饰形参，防止形参改变实参

示例1：

#include<iostream>
using namespace std;

int main() {
   
	int a = 10;
	//int& ref = 10;//引用必须引用合法的内存空间，不能直接引用数值
	const int& ref = 10;//加上const之后，编译器将代码修改为：int temp = 10; const int& ref = temp;
	//ref = 20;//加入const之后，变成只读状态，不可以修改

	cout << "a：" << a << endl;
	cout << "ref：" << ref << endl;

	system("pause");
	return 0;
}

示例2：

#include<iostream>
using namespace std;

void showValue(const int& ref) {
   //加入const后无法修改数据，防止误操作
	//ref = 1000;//无法修改
	cout << "value：" << ref << endl;
}

int main() {
   
	int a = 100;
	showValue(a);

	system("pause");
	return 0;
}

3 函数提高

3.1 函数默认参数

在C++中，函数的形参列表中的形参是可以有默认值的。

语法：返回值类型 函数名 (参数 = 默认值) {}

示例：

#include<iostream>
using namespace std;

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

//1.如果某个位置已经有了默认参数，那么从这个位置往后，从左到右都必须有默认值
//int func(int a= 20, int b, int c) {//这一行有误，b和c必须有默认参数，才是正确的
//	return a + b + c;
//}

//2.如果函数的声明有默认参数，函数实现就不能有默认参数。函数声明和函数实现只能有一个有运行参数
//虽然代码没有报错，但是存在错误
int func2(int a = 10, int b = 10);

int main() {
   
	int a = 100;
	cout << func(10) << endl;
	cout << func(10, 30) << endl;//如果传了某个值，则用传过去的值
	cout << func2() << endl;

	system("pause");
	return 0;
}

int func2(int a, int b) {
   
	return a + b;
}

总结：

  1. 如果函数实现中某个位置已经有了默认参数，那么从这个位置往后，从左到右都必须有默认值；
  2. 如果函数实现中已经定义了默认参数的值，如果主函数中如果调用这个函数，则用传过去的值进行函数运算；
  3. 如果函数的声明有默认参数，函数实现就不能有默认参数。函数声明和函数实现只能有一个有运行参数。

3.2 函数占位参数

C++中函数的形参列表里可以有占位参数，用来做占位，调用函数时必须填补该位置。

语法：返回值类型 函数名 (数据类型) {}

在现阶段函数的占位参数存在意义不大，但是后面的课程中会用到该技术。

示例：

#include<iostream>
using namespace std;

//占位参数还可以有默认参数，例如：
//void func(int a,int = 10) {
   
void func(int a,int) {
   
	cout << "This is function." << endl;
}

int main() {
   
	int a = 100;
	func(a,10);//调用时必须填补该位置

	system("pause");
	return 0;
}

3.3 函数重载

3.3.1 函数重载概述

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

函数重载满足条件：

  • 同一个作用域下
  • 函数名称相同
  • 函数参数类型不同或者个数不同或者顺序不同

注意：函数的返回值不可以作为函数重载的条件

示例：

#include<iostream>
using namespace std;

//函数重载
//可以让函数名相同，提高复用性
void func() {
   
	cout << "func 的调用" << endl;
}

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

void func(double a) {
   
	cout << "func(double a) 的调用" << 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;
	return 0;
}
*/
int main() {
   
	func();
	func(10);
	func(3.14);
	func(10, 3.14);
	func(3.14,10);

	system("pause");
	return 0;
}
3.3.2 函数重载注意事项
  • 引用作为重载条件
  • 函数重载碰到函数默认参数

示例：

#include<iostream>
using namespace std;

//函数重载的注意事项
//引用作为重载的条件
void func(int& a) {
      //可读可写
	cout << "func(int& a) 的调用" << endl;
}

void func(const int& a) {
      //加入const只能读不能写；合法的代码
	cout << "func(const int& a) 的调用" << endl;
}

void func2(int a,int b = 10) {
      //当函数重载碰到默认参数会存在二义性，报错，尽量避免这种情况
	cout << "func(int a,int b = 10) 的调用" << endl;
}

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

int main() {
   

	int a = 10;
	func(a);
	func(10);
	//func2(10);//该行代码会报错，由于函数重载碰到默认参数会存在二义性
	func2(10, 20);//和上面注释的代码形成对比，这一行代码不存在二义性

	system("pause");
	return 0;
}

4 类和对象

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

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

例如：

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

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

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

4.1 封装

4.1.1 封装的意义

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

封装的意义：

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

封装的意义一：

​ 在设计类的时候，属性和行为写在一起，表现事物

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

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

#include<iostream>
using namespace std;

const double pi = 3.14;//圆周率

//设计一个圆类，求圆的周长
//圆求周长的公式：2*pi*半径

//class代表设计一个类，类后面紧跟着就是类的名称
class Circle {
   
	//访问权限
public:  //访问权限，公共权限
	//属性
	int m_r;//半径
	//行为：获取圆的周长，可以用一个函数
	double calculateZC() {
   
		return 2 * pi * m_r;
	}
};

int main() {
   
	//通过圆类创建具体的圆（对象）
	Circle c1;//通过类实例，创建一个对象
	c1.m_r = 10;
	cout << "圆的周长为：" << c1.calculateZC() << endl;

	system("pause");
	return 0;
}

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

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

class Student {
   
public:  //访问权限，公共权限
	//类中的属性和行为统一称为成员
	//属性：成员属性，成员变量
	string name;//姓名
	int number;//学号
	//行为：成员函数，成员方法
	void showStudent() {
   
		cout << "学生的姓名：" << name << endl;
		cout << "学生的学号：" << number << endl;
	}

	void setStudent(string name1) {
   
		name = name1;
	}

	void setnumber() {
   
		cout << "请输入学号：" << endl;
		cin >> number;
	}
};

int main() {
   
	//创建对象
	Student s1;//通过类实例，创建一个对象
	s1.setStudent("张三");
	s1.setnumber();
	s1.showStudent();

	Student s2;//通过类实例，创建一个对象
	s2.setStudent("李四");
	s2.setnumber();
	s2.showStudent();

	system("pause");
	return 0;
}

封装的意义二：

​ 类在设计时，可以把属性和行为放在不同的权限下，加以控制

访问权限有三种：

  1. public 公共权限
  2. protected 保护权限
  3. private 私有权限

示例：

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

//访问权限：公共权限、保护权限、私有权限
class person {
   
public:  //成员类内可以访问，类外可以访问
	string name;//姓名
	//
protected:
	string car;//保护权限内容类外无法访问
private:
	int password;//私有权限内容类外无法访问
public:
	void func() {
   
		name = "张三";
		car = "拖拉机";
		password = 123456;
	}
	void output() {
     //外部无法访问可以通过内部输出来查看
		cout << "输出所有信息：" << endl;
		cout << name << endl;
		cout << car << endl;
		cout << password << endl;
	}
};

int main() {
   
	//创建对象
	person p1;

	//p1.car = "奔驰";//保护权限的内容在类外无法访问，该行密码报错
	p1.func();
	p1.name = "李四";
	p1.output();

	system("pause");
	return 0;
}

总结：

  • 公共权限 public 成员 类内可以访问 类外可以访问
  • 保护权限 protected 成员 类内可以访问 类外不可以访问 在继承中，儿子也可以访问父亲中的保护内容
  • 私有权限 private 成员 类内可以访问 类外不可以访问 在继承中，儿子无法访问父亲中的私有内容
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() {
   
	//创建对象
	C1 c1;
	//c1.m_a = 100;//无法访问，
	C2 c2;
	c2.m_a = 100; //在struct中默认的权限为公共，因此可以访问

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

优点：

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

示例：

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

class Person {
    
public:
	//写姓名
	void setname(string name1) {
   
		name = name1;
	}
	//获取姓名
	string getname() {
   
		return name;
	}
	int getage() {
   
		//age = 0;
		return age;
	}
	void setlover(string lover1) {
   
		lover = lover1;
	}
	void setage(int age1) {
   
		if (age1 < 0 || age1>150) {
   
			age = 0;
			cout << "你这个老妖精！" << endl;
			return;
		}
		age = age1;
	}
private:
	string name;//设置可读可写权限
	int age;//设置只读权限
	string lover;//设置只写权限
};

int main() {
   
	Person p;
	p.setname("张三");
	cout << "姓名：" << p.getname() << endl;
	p.setage(10);
	cout << "年龄：" << p.getage() << endl;
	p.setlover("Eureka");
	system("pause");
	return 0;
}
练习案例1：设计立方体类

设计立方体类（Cube）

求出立方体的面积和体积

分别用全局函数和成员函数判断两个立方体是否相等

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

class Cube {
   
private:
	int m_L;
	int m_W;
	int m_H;
public:
	//设置长
	void setL(int L) {
   
		m_L = L;
	}
	//获取长
	int getL() {
   
		return m_L;
	}
	//设置宽
	void setW(int w) {
   
		m_W = w;
	}
	//获取宽
最低0.47元/天 解锁文章
ywwsnowboy
关注
C++从入门到进阶的系列书籍推荐（22本书）
dvlinker的技术专栏
11-05 3万+
要多读书，读好书！一本书要多读几遍才好，每次都可能有新的收获！特别在是有一定的工作年限和工作经验之后！读书百遍，其义自见！ 下面就给大家推荐一下C++程序员进阶需要读的经典书籍： 1、C++入门书籍 C++是在C语言的基础上发展而来的，要学习C++之前需要先学习C语言。有了C语言基础之后再去学习C++。 1.1、C语言程序设计（谭浩强） 该书被公认为学习C语言程序设计的优秀教材，被全国大多数高校选用，是学习C语言的主流用书。本书比较通俗易懂，是初入者必备的书籍。 ........
C++编程学习
05-09
C++经典编程案例200例，继承，多态，接口，模板，容器等
C++编程学习(一) —— C++入门
m0_66238629的博客
06-29 1795
所谓数组，就是一个集合，里面存放了相同类型的数据元素特点1：数组中每个数据元素都是相同的数据类型特点2：数组是由连续的内存位置组成的数据类型 数组名[ 数组长度 ];数据类型 数组名[ 数组长度 ] = { 值1, 值2, ...};数据类型 数组名[ ] = { 值1, 值2, ...};//int a[5];//如果初始化数据没有全部填写完所有的数据，会在后面自动补0//定义数组时必须确定初始长度i < 5;i++)i < 6;
1 c++编程基础
xiuling216的博客
06-16 1662
c++编程学习及总结
开始学习C++编程语言
gkht007的博客
03-20 597
2018年3月20日，首次接触C++语言，并开始学习编写程序，兴趣很浓，知识却匮乏。编写的第一个程序如下：# include&lt;stdio.h&gt;int main(){printf("Hello World");}现在算是日记的第一页，以后会每天更新一次，作为随堂笔记，也算学习心得。...
c++编程学习的技巧总结
12-26
2、看《Thinking In C++》，不要看《C++编程思想》。 3、看《The C++ Programming Language》和《Inside The C++ Object Model》，不要因为他们很难而我们自己是初学者所以就不看。 4、不要被VC、BCB、BC、MC、TC等...
C++编程学习(三) —— C++高级编程
m0_66238629的博客
06-29 91
C++进阶编程 本阶段主要针对C++泛型编程和STL技术做详细讲解，探讨C++更深层的使用 1 模板 1.1 模板的概念 模板就是建立通用的模具，大大提高复用性。 例如生活中的模板 一寸照片的模板： PPT模板 模板的特点： 模板不可以直接使用，它只是一个框架 模板的通用并不是万能的 1.2 函数模板 C++另一种编程思想称为泛型编程，主要利用的技术就是模板 C++提供两种模板机制：函数模板和类模板 1.2.1 函数模板语法 函数模板作用：建立一个通用函数，其函数返回值类型和形参类型可以不
c++期末大作业——音乐游戏.zip
最新发布
12-27
这份复习资料适用于学习C/C++的各类人群，无论是初学者还是有一定编程基础的学生，都能从中获得收益。 四、使用建议 我们建议您先从基础知识开始复习，逐步深入到进阶概念。在掌握基本知识点后，结合复习题进行...
C++学习心得 编程经验
03-18
很好的讲解了容易被忽略的C++问题，是一本很好的电子书
新手学编程系列：新手学C++
11-11
c++入门教程，实例丰富，实用性强，讲解通熟易懂，内容充实，层次分明，可共初学者学习用。
C/C++ 编程学习及自学教程
亮亮的专栏
07-03 1102
本文主要介绍分享C语言编程学习，以辅助自学编程的教程，相关知识文档。 1、C 教程 C语言简介 C语言集成开发环境 C语言入门教程 C语言编写代码语法 C语言注释作用写法及示例代码 C语言变量 C语言常量 C语言存储类型 C语言数据类型 C语言运算符 C语言条件语句(If else) C语言 switch case 语句 C语言while循环语句 C语言 for循环语句 C语言 break和continue关键字 C语言 数组 C语言函数 C语言作用域 C语言递归
C++多线程编程学习（1）：
hpu_lx
08-12 202
多线程编程学习（1） 1.创建一个线程 开关线程的API函数： HANDLE CreateThread( LPSECURITY_ATTRIBUTES lpThreadAttributes, //SD：线程安全属性，常置为NULL SIZE_T dwStackSize, //initialstacksize：初始化栈的大小，可设置为0 LPTHREAD_START_ROUTINE lpStar...
程序员如何学习C++
2301_77769537的博客
04-26 318
为了熟练掌握C++语法，程序员需要不断地进行练习，编写不同难度的程序，例如简单的控制台程序、图形界面程序、网络应用程序等等，这样才能更好地理解和运用C++语法。总之，参加课程和培训只是程序员学习C++的一个方面，而要真正成为一名优秀的C++程序员，还需要付出更多的努力和时间。在学习C++的高级特性时，程序员需要投入更多的时间和精力，但这将带来巨大的回报。除了编写一些简单的程序来帮助程序员更好地理解C++的语法和特性之外，还可以参与开源项目，与其他开发人员一同讨论和解决问题，探索不同的编程思路。
【C++ 编程语言学习1】 类&对象详解
wb790238030的博客
01-03 2201
目录  类的基本概念、类成员函数、类访问修饰符、构造函数&amp;析构函数、C++拷贝构造函数、C++友元函数、C++中的this指针、C++中指向类的指针、C++类的静态成员 一、类的基本概念    类是把属性和方法进行封装，同时对类的属性和方法进行访问控制（类可以把自己的属性和方法只让可信的类或者对象操作，对不可信的进行信息的隐藏） 类是由我们根据客观事物抽象而成，形成一类事物，然后...
2020 C++编程学习之路（持续更新）
Tylers_zhang的博客
02-03 1206
2020.04.16 距离上一次编辑博客已经过去了2个多月，看到自己写的博客已经有100+的浏览非常惊讶，其实笔者一直没有更新并不是就此停滞不前了(），而是在通过视频网课和《C++ Prime Plus》学习C++，通过两个月的时间，笔者也逐渐接受了C++的语法习惯以及C++的一大特色——。笔者在学习C++编程之前，所以想向已经接触过C语言或者编程的同学一些学习C++的。
C++/C编程学习：梳理06---makefile总结04
一片雾霾的博客
03-10 173
转 Makefile讲义(4)——书写命令 转 makefile讲义(5)——使用变量 转 makefile讲义(6)——条件判断 转 Makefile讲义(7)——使用函数 转 Makefile讲义(8)——make 的运行 转 Makefile讲义(9)——隐含规则 转 Makefile讲义(10)——更新函数库文件 转 Makefile讲义(11)——后序 ...
C++入门学习
Kun2631的博客
04-07 146
（4）.const修饰的引用不可以直接更改变量的值，但是变量的值更改之后，可以改变引用的值。但是需要参数列表需要不同，需要参数的个数不同或者参数的类型不同。内联函数可以提高程序的运行效率，编译的时候，会把函数体的内容展到调用位置，节省了函数调用的时间。传引用：引用做参数的好处是不需要为形参开辟内存空间 ，也不需要为其赋值。如果传入参数，会用传入的参数替代默认值。2）.当函数有多个参数时，中间有一个参数有默认值，其后的的参数都需要有默认值。传值：函数形参只是实参的拷贝，形参改变，不会影响实参的值。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

ywwsnowboy

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值