C++入门基础（三）

已于 2024-05-20 15:32:19 修改
阅读量828 收藏 46
点赞数 48
分类专栏： C++ 文章标签： c++ 开发语言 链表 数据结构 学习方法 笔记 课程设计
于 2024-05-03 10:33:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79178723/article/details/138140165
版权

目录


感谢各位大佬对我的支持,如果我的文章对你有用,欢迎点击以下链接
🐒🐒🐒 个人主页
🥸🥸🥸 C语言
🐿️🐿️🐿️ C语言例题
🐣🐣🐣 python
🐓🐓🐓 数据结构C语言
🐔🐔🐔 C++
🐿️🐿️🐿️ 文章链接目录

引用

引用概念

引用不是新定义一个变量，而是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空
间，它和它引用的变量共用同一块内存空间。在这里插入图片描述

比如：同学A有一个别名为张三，张三是同学A，张三和同学A指的都是同一个人，在C++中同学A可能是int类型，也可能是char类型，甚至可能是int*类型或int**类型…

因为引用的符号和去地址符号是相同的，就像之前的左移操作符和流插入一样，所以C++是可以同时支持取地址和引用的

例子1

#include<iostream>
using namespace std;
int main()
{
	int a = 0;
	int& b = a;
	cout << &b << endl;
	cout << b << endl;
}

在这里插入图片描述

这段代码中&b=a表示b是a的别名，打印的时候
cout<<&b<<endl表示打印a别名的地址
cout<<b<<endl则表示打印a的别名
注意：引用类型必须和引用实体是同种类型的

b既然是a的别名,b的地址也应该和a的地址一样(因为都表示的是同一个人)
在这里插入图片描述

那如果更改b的值,a的值是否又会更改呢?

在这里插入图片描述

显然是可以的,因为b就是a,只是换了个名字而已

例子2

别名是可以无限取的，就跟一个人的外号一样，不一定只有一个外号，同时也可以给一个人的外号取别名，比如同学B叫同学A为张三，同学C叫同学A为张四，有时同学C也爱叫张四为张五

	int main()
	{
		int a = 0;
		int& b = a;
		int& c = b;
		int& d = a;
		cout << a << endl;
		cout << b << endl;
		cout << c << endl;
		cout << d << endl;
		return 0;
	}

在这里插入图片描述

例子3

对一个人取外号，这个人必须是存在的，所以引用在定义时必须初始化

在这里插入图片描述
如果我们写int &a=0，这样会被认为a是一个地址
在这里插入图片描述

例子4

一个变量可以有多个别名，而一个别名是不可以是多个变量的

	int main()
	{
		int a = 0;
		int c = 1;
		int& b=a;
		int& b = c;
		return 0;
	}

在这里插入图片描述
再来看看下面这段代码

	int main()
	{
		int a = 0;
		int& b = a;
		int c = 2;
		b = c;
		cout << b << endl;
		cout << a << endl;
		return 0;
	}

在这里插入图片描述

这里的b并不是c的别名，之前是 int& b = c，这里是b=c，只是将c对值赋值给b，但是b不是c的别名

常引用

常引用的出现是为了解决当引用作为参数传参时被修改的情况

void func(int& x)
{
	x++;
}
int main()
{
	int a = 0;
	int& b = a;
	b++;
	cout << a << endl;
	func(a);
	cout << a << endl;
}

这里的b作为a的别名,通过引用传参传进func函数中,func函数的x也是a的别名,所以x++,影响到了函数外的a
在这里插入图片描述
为了解决这种情况,可以用const去修饰
在这里插入图片描述
const修饰使参数的权限变小,让x不能被修改,但是可以给其他变量赋值
在这里插入图片描述
下面三张图也是因为const修饰引起的权限问题
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

coust修饰的int对象可以和其他coust修饰的int对象相加,因为权限都相同
在这里插入图片描述
所以可以得出结论,权限是不能放大的
比如下面的代码,我们对a进行const修饰,然后将a通过引用传参传给func函数中,最后会报错

void func( int& x)
{
	;
}
int main()
{
 const int a= 1;
 func(a);

}

在这里插入图片描述
而当我们对func函数中的x用const修饰后就可以正常运行了,这是因为xa是被const修饰的,所以是不可以被更改的,而x作为a的别名理应也不可以被修改,但是x没有被const修饰,导致权限放大,所以才会报错
在这里插入图片描述

拓展

我们知道double类型传给int类型的时候会出现数据丢失,当我们用int类型的ri作为d的别名是会报错
在这里插入图片描述
但是当在int &ri前加const修饰后却可以正常运行
在这里插入图片描述
这里就需要知道类型转换的时候会产生临时变量,也就是说并不是d直接赋值给ri,而是通过d构造出一个int类型的临时变量
所以这里的ri是临时变量的别名,而我们知道临时变量是具有常性的,在没有const修饰的情况下是出现了权限放大,导致出错,而加上了const修饰后权限就相等了,所以没有报错
在这里插入图片描述
那为什么要产生临时变量呢?

int main()
{
	int i = 97;
	char ch = 'a';
	if (i == ch)
	{
		cout << "i=ch" << endl;
	}

}

当操作符两边的操作数类型不相等时会出现类型提升或者截断,像上边的const int&ri=d是将d整形的部分截断给临时变量,然后ri再去拷贝临时变量

而这里的char ch = 'a’是类型的提升,因为ch只占1个字节,而i是整形占4个字节,所以临时变量会占4个字节,将ch给临时变量,然后临时变量按类型提升的规则,最高位往上补0,最后ch的ASCLL码值和i相同,所以打印出i=ch
在这里插入图片描述

引用的应用

做参数

	#include<iostream>
	using namespace std;
	void Swap(int& a, int& b)
	{
		int temp = a;
		a = b;
		b = temp;
	}
	int main()
	{
		int c = 0, d = 1;
		cout << c <<'\n' << d << endl;
		Swap(c, d);
		cout << c <<'\n' << d << endl;
		return 0;
	}

在这里插入图片描述
在C语言中的写法为

	void Swap(int* a, int* b)
	{
		int temp = *a;
		*a = *b;
		*b = temp;
	}
	int main()
	{
		int c = 0, d = 1;
		printf("%d %d ", c, d);
		Swap(&c, &d);
		printf("%d %d ", c, d);
		return 0;
	}

在这里插入图片描述
可以看出，C语言在实现Swap函数的时候，需要考虑Swap的参数类型，如果要传入地址就需要让参数类型变成int*类型，然后在传参时需要将参数的地址传进去
而C++则要简单一点，如果想要修改函数外面的变量，那么就让参数类型变成别名，这样就不需要考虑要不要传地址了

做返回值

	int func()
	{
		int a = 0;
		return a;
	}
	int main()
	{
		int ret = func();
		return 0;
	}

这段代码中不是把a的值给ret，这里需要再理解一下函数栈帧
main函数调用时会建立一块栈帧，局部变量ret会在里面开一块空间，当函数结束的时候局部变量就会销毁
在这里插入图片描述
main函数中调用了函数func，然后func函数会建立一块新的栈帧，a是func函数中的一个局部变量，所以回走func函数建立的栈帧里开一块空间
在这里插入图片描述
在这里插入图片描述
当func函数结束后，他开辟的空间就会销毁，而a也是会跟着销毁的，如果将a对值返回给ret，那么ret接受的可能是一个随机值
而不同的平台输出的值不同，VS中输出的是a的值，但并不代表a把值返回给了ret
在这里插入图片描述
因为VS会开辟一块空间，里面有一个临时变量，临时变量的值等于函数的返回值，当func函数结束后临时变量的空间是不会被销毁的，然后将临时变量的值返回给ret

注意：如果函数返回时，出了函数作用域，如果返回对象还在(还没还给系统)，则可以使用
引用返回，如果已经还给系统了，则必须使用传值返回

野引用

当我们强行让函数的返回值变成别名的时候，就会报错

	int& func()
	{
		int a = 0;
		int b = 1;
		return b;
	}
	int main()
	{
		int ret = func();
		cout << ret << endl;
		return 0;
	}

在这里插入图片描述
这种情况和指针类似，指针中的野指针是指向一块内存被释放或者没有访问权限的指针，这里的引用是取了一个变量a的别名，而a的空间已经被释放掉了，但是仍然要返回a的别名，导致出现了野引用
（实质就是a的空间被释放掉了，但是最后还要去访问a的空间，而空间里的值是一个随机值，导致输出结果不确定）
不同的平台结果不一样，VS中没有将a的栈帧销毁，所以ret接收到是a的值
在这里插入图片描述
如果我们让ret是func返回值的别名会怎么样？

	using namespace std;
	int& func()
	{
		int a = 0;
		return a;
	}
	int main()
	{
		int &ret = func();
		cout << ret << endl;
		return 0;
	}

ret为a的别名，所以ret的空间就是a的空间，而a的空间在func函数新开辟的空间中，所以ret在main函数中没有空间，最后因为a的空间会被释放，导致ret也成了也引用
在这里插入图片描述
在这里插入图片描述

扩展

	int& func()
	{
		int a = 0;
		return a;
	}
	void fx()
	{
		int b = 3;
	}
	int main()
	{
		int &ret = func();
		cout << ret << endl;
		fx();
		cout << ret << endl;
		return 0;
	}

在这里插入图片描述
ret明明是a的别名，但是在调用一个函数fx后就变了
后面再调用一次func后，ret的值又变回来了

如果让fx函数的返回值后面加个引用符号会怎么样？
最终结果没有变化
在这里插入图片描述

在这里插入图片描述
上面的情况是因为空间可以互用的，当func函数调用完后，会销毁空间，而调用fx函数后，原来的那块空间就会给到fx

因为ret是野引用，ret的地址仍然指向原来空间的地址，但是由于后面那块空间被分给了fx，所以ret的值又变成了fx中b的值

如果fx中没有定义b会怎么样
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
这个例子更能体现出ret为野引用后的随机性

总结：传值返回是返回 返回值的拷贝，传引用返回是返回 返回值的别名，返回变量出了函数作用域后生命周期（局部变量）就结束了，不能引用返回而像全局变量 静态变量（static修饰） 堆上变量等这些就可以用引用返回

传值、传引用效率比较

以值作为参数或者返回值类型，在传参和返回期间，函数不会直接传递实参或者将变量本身直
接返回，而是传递实参或者返回变量的一份临时的拷贝，因此用值作为参数或者返回值类型，效
率是非常低下的，尤其是当参数或者返回值类型非常大时，效率就更低。

#include <time.h>
	struct A { int a[10000]; };
	void TestFunc1(A a) {}
	void TestFunc2(A& a) {}
	int main()
	{
		A a;
		size_t begin1 = clock();
		for (size_t i = 0; i < 10000; ++i)
			TestFunc1(a);
		size_t end1 = clock();
		size_t begin2 = clock();
		for (size_t i = 0; i < 10000; ++i)
			TestFunc2(a);
		size_t end2 = clock();

		cout << "TestFunc1(A)-time:" << end1 - begin1 << endl;
		cout << "TestFunc2(A&)-time:" << end2 - begin2 << endl;
		return 0;
	}

这段代码是为了比较传值、传引用的效率，为了更容易看出他们直接到效率差距，所以定义了一个比较大的结构体，然后分别调用10000次函数，size_t begin = clock()是记录刚开始调用函数的时间， size_t end = clock()是记录调用结束后的时间，二者相减就可以得到调用函数所耗的时间
在这里插入图片描述
这里的0毫秒是接近于0，通过这段代码可以看出，引用传参效率更高

引用和指针的区别

引用的语法和底层是有一些不一样的
举个例子鱼香肉丝语法角度看有鱼有肉丝，而底层实现只有肉丝

语法角度引用是别名，不开空间，而指针是地址需要开空间存地址
而通过下面的代码调试看汇编可以得出引用也是会开空间的，事实上引用的底层是通过指针实现的

int main()
{
	int a = 10;
	int& ra = a;
	ra = 20;

	int* pa = &a;
	*pa = 20;
	return 0;
}

在这里插入图片描述
这里补充一下汇编的查找方法
先进行调试，然后点击鼠标右键，就可以找到汇编了
在这里插入图片描述

引用和指针的不同点:

  1. 引用概念上定义一个变量的别名，指针存储一个变量地址。
  2. 引用在定义时必须初始化，指针没有要求
  3. 引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何
    一个同类型实体（引用不能改变指向，指针可以）
  4. 没有NULL引用，但有NULL指针（引用相对更安全，没有空引用，但是有空指针，容易出现野指针，但是不容易出现野引用）
  5. 在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32
    位平台下占4个字节)
  6. 引用自加即引用的实体增加1（i++…），指针自加即指针向后偏移一个类型的大小（ * a+1）
  7. 有多级指针（int ** a），但是没有多级引用
  8. 访问实体方式不同，指针需要显式解引用，引用编译器自己处理
  9. 引用比指针使用起来相对更安全

C++对比C语言实现顺序表

C语言实现顺序表可以查看顺序表详解
下面简单的用C++实现顺序表的一些功能

struct SeqList
{
	int* a;
	int size;
	int capacity;
	void Init()
	{
		a = (int*)malloc(sizeof(int) * 4);
		//..
		size = 0;
		capacity = 4;
	}
	void PushBack(int x)
	{
		//扩容
		a[size++] = x;

	}
	int SLGet(int pos)
	{
		assert(pos >= 0);
		assert(pos < size);
		return a[pos];
	}
};

C语言是数据和函数分离，而C++可以将函数写在结构体里，并且可以看到，许多函数传入的参数都非常少，甚至没有传参的

因为这些函数是在结构体内部，而结构体里又定义了int a int size，int capacity这些参数，结构体内部的函数是可以直接用这些参数的，而像x和pos这些结构体里没有的参数就需要我们传参，这样就使C++实现顺序表变得很简单，很容易看懂*

对比C语言中因为数据和函数是分离的，导致像int* a int size，int capacity这些作为参数必须要写明是哪个结构体中的数据，否则就会分不清，而C++因为函数在结构体内部，这些数据都不需要写明就知道是在哪个结构体中

我们用代码测试一下功能
因为函数在结构体内部，所以调用函数的时候就可以直接当成结构体中的成员访问

打印顺序表中的数据

int main()
{
	SeqList sl;
	sl.Init();
	sl.PushBack(1);
	sl.PushBack(2);
	sl.PushBack(3);
	sl.PushBack(4);
	for (int i = 0; i < sl.size; i++)
	{
		cout << sl.SLGet(i) << "";
	}
	return 0；
}

在这里插入图片描述

修改顺序表中的数据

int main()
{
	SeqList sl;
	sl.Init();
	sl.PushBack(1);
	sl.PushBack(2);
	sl.PushBack(3);
	sl.PushBack(4);
	for (int i = 0; i < sl.size; i++)
	{
		if (sl.SLGet(i) % 2 == 0)
		{
			sl.SLGet(i) *= 2;
		}
	}
	for (int i = 0; i < sl.size; i++)
	{
	cout << sl.SLGet(i) << endl;
	}
}

当想修改顺序表中的数据时，却出现表达式必须是可修改的左值，说明sl.SLGet(i) *= 2中的sl.SLGet(i)为一个常量，比如1=2，1就是一个常量，我们修改不了他
在这里插入图片描述
要想解决就先得看一下int SLGet(int pos)的实现

int SLGet(int pos)
	{
		assert(pos >= 0);
		assert(pos < size);
		return a[pos];
	}

显然SLGet函数返回类型为int类型，也就是说返回的是一个临时变量，C++规定临时变量具有常性，也就是说这个临时变量就是一个常量

为了解决这个问题，就需要用到引用int& SLGet(int pos)，由于pos位置的值是用malloc开辟出来的，当出了作用域后不会被销毁，所以用引用取别名，仍然可以访问到pos位置的值
在这里插入图片描述

内联函数

函数调用是需要建立栈帧的，如果频繁的调用同一个函数那么会损耗非常多的空间

C语言解决这个问题的方式是通过宏（#define…），其原理就是宏在预处理阶段进行了替换
举个例子：用宏实现加减函数

#define ADD(a,b)((a)+(b))
int main()
{
	cout << ADD(1 + 2, 3 - 1) << endl;
	return 0;
}

在这里插入图片描述

需要注意的是
1：宏不是函数，所以ADD括号中没有参数类型
2：宏没有分号，因为宏是用来替换的，如果有分号会把分号野加进去
3：需要用括号控制优先级
如果没有用对括号就会出现下面的这种情况,实现乘法函数的结果会出错
在这里插入图片描述
在这里插入图片描述
宏也有缺点
1：语法复杂，很容易出错
2：不能调试，因为在预处理阶段直接就替换掉了
3：没有类型安全的检查
在这里插入图片描述
在这里插入图片描述

C++的解决方式就用内联函数

概念

以inline修饰的函数叫做内联函数，编译时C++编译器会在调用内联函数的地方展开（类似宏的替换），没有函数调用建立栈帧的开销，内联函数提升程序运行的效率。

 int ADD(int a, int b)
{
	return a + b;
}
int main()
{
	cout<<ADD(1, 2) << endl;
	return 0;
}

在没有加inline的情况下，汇编红色方框ADD的括号里就是函数地址（0101100Ah），每次使用ADD的时候都要调用函数建立栈帧
在这里插入图片描述

 inline int ADD(int a, int b)
{
	return a + b;
}
int main()
{
	int ret1 = ADD(1, 2) * 3;
	int x = 1, y = 1;
	int ret2 = ADD(x | y, x & y);
	return 0;
}

加上inline后，也在仍然在调用函数的地址，这是因为debug版本中默认没有将inline修饰的函数进行替换
在这里插入图片描述
想要看展开后的结果需要进行设置

首先需要找到属性
在这里插入图片描述
将常规中调试信息格式设置成程序数据库

在这里插入图片描述
然后再将优化中内联函数扩展设置成只使用于inline
在这里插入图片描述
再去看汇编，这一次就没有再调用函数了
在这里插入图片描述

特性

内联函数虽然好，但是不可以无脑的使用
举个例子，假设一个函数有100行代码，有1w个调用的位置
假设inline展开：100*1w行代码（全部替换）
假设没有inline展开：100+1w代码
这种情况使用inline函数会导致编译的程序变大，当编译程序变大后，如果想要下载这个程序，就需要花很长的时间（游戏更新也是这样的）

总结

  1. inline是一种以空间换时间的做法，如果编译器将函数当成内联函数处理，在编译阶段，会
    用函数体替换函数调用
    缺陷：可能会使目标文件变大
    优势：少了调用开销，提高程序运行效率。

  2. inline对于编译器而言只是一个建议，不同编译器关于inline实现机制可能不同
    一般建议：将函数规模较小(即函数不是很长，具体没有准确的说法，取决于编译器内部实现)、不是递归、且频繁调用的函数采用inline修饰，否则编译器会忽略inline特性

《C++prime》第五版对于inline的建议：内联说明只是想编译器发出的一个请求，编译器可以选择忽略这个请求，一般来说，内联机制用于优化规模较小，流程直接，频繁调用的函数，很多编译器都不支持内联递归函数（加了inline可能编译器会忽略掉），而且一个75行的函数也不大可能在调用内联函数展开

通过下面的代码演示情况

//Stack.h
#include<iostream>
using namespace std;
inline int ADD(int a, int b)
{
	cout << "int ADD(int a, int b)" << endl;
	cout << "int ADD(int a, int b)" << endl;
	cout << "int ADD(int a, int b)" << endl;
	cout << "int ADD(int a, int b)" << endl;
	cout << "int ADD(int a, int b)" << endl;
	cout << "int ADD(int a, int b)" << endl;
	cout << "int ADD(int a, int b)" << endl;
	return a + b;
}
//test.cpp
#include"Stack.h"
 int main()
{
	int ret=ADD(1, 2);
	return 0;
}

在汇编中可以看到没有call ADD函数
在这里插入图片描述
而用下面这个代码就不一样了

//Stack.h
#include<iostream>
using namespace std;
inline int ADD(int a, int b)
{
	cout << "int ADD(int a, int b)" << endl;
	return a + b;
}
//test.cpp
#include"Stack.h"
 int main()
{
	int ret=ADD(1, 2);
	return 0;
}

汇编中有call ADD函数，也就是忽略了inline的请求

在这里插入图片描述

  1. inline不建议声明和定义分离，分离会导致链接错误。因为inline被展开，就没有函数地址
    了，链接就会找不到。
    举个例子
//test.cpp
#include"Stack.h"
int main()
{
	ADD(1, 2);
	return 0;
}
//Stack.h
#include<iostream>
using namespace std;
int ADD(int a, int b)
{
	cout << "int ADD(int a, int b)" << endl;
	return a + b;
}

这样说可以运行的通的
在这里插入图片描述
而如果Stack.h在多个地方包含就会报错
在这里插入图片描述
在这里插入图片描述
这种情况是因为在test.cpp中包含了Stack.h中的ADD函数，而Stack.cpp也包含了ADD函数，因为都包含了Stack头文件，然后Stack.cpp和Stack.h会生成Stack.o,test.cpp会生成test.o,之后在链接过程中会将Stack.o和test.o都合并到一起,而因为Stakc.cpp和test.cpp都包含了ADD函数，所以不会构成函数重载，所以就会报错

但是这里有一个需要注意的地方
#pragma once是解决不了上面的问题的
在这里插入图片描述
#pragma once是为了解决比如test,cpp中重复包含了两次Stack.h,或者间接包含了两次,会在编译的预处理阶段删掉一些重复包含的东西,是解决同一个文件中重复包含的情况
在这里插入图片描述
而上面的重定义是发生在同一个函数在不同的文件发生的,这种情况就需要声明和定义分离

//test.c
#include"Stack.h"
int main()
{
	ADD(1, 2);
	return 0;
}
//Stack.h
#include<iostream>
using namespace std;
int ADD(int a, int b);
//Stack.cpp
#include"Stack.h"
int ADD(int a, int b)
{
	cout << "int ADD(int a, int b)" << endl;
	return a + b;
}

在这里插入图片描述
Stack.cpp中包含的Stack.h展开只有声明,test.cpp中包含的Stack.h展开也只有声明,具体的函数实现在Stack.cpp中

当后面Stack.o和test.o合并的时候,就不会发生重定义了

因为在链接过程当中test.cpp会去寻找函数的地址,而函数的具体实现在Stakc.c中,Stack.h只是声明了函数,所以最后找到的函数地址在Stack.c里

第二种解决方式就是static修饰函数
static修饰函数,会让函数的链接属性只在当前文件可见(test.cpp中包含的ADD只能在test.cpp里可见，stack.cpp中也是一样的,简单的来说就是而Stack.cpp看不到test.cpp中有ADD函数，test.cpp也同样看不到Stack.cpp包含了ADD函数)

第三种方式用内联函数

//Stack.h
inline int ADD(int a, int b);
Stack.cpp
#include"Stack.h"
inline int ADD(int a, int b)
{
	cout << "int ADD(int a, int b)" << endl;
	return a + b;
}
test.cpp
#include"Stack.h"
 int main()
{
	ADD(1, 2);
	return 0;
}

因为内联函数是直接展开的,所以在链接的时候会被认为不需要找到函数的地址,test.cpp中用到的ADD就是因为没有找到对于函数的地址导致报错
在这里插入图片描述
正确的方法是直接在Stack.h中定义

Stack.h
#include"Stack.h"
inline int ADD(int a, int b)
{
	cout << "int ADD(int a, int b)" << endl;
	return a + b;
}
test.cpp
#include"Stack.h"
 int main()
{
	ADD(1, 2);
	return 0;
}

在这里插入图片描述
Stack.cpp中和test.cpp中明明是包含了Stack.h,为什么却不像之前那样报错呢?

其实是因为inline和static原理类似

总结
复杂的函数通常用声明和定义分离以及static修饰,简单的函数则一般用inline

MrGaomq
关注
专栏目录
C++基础入门.pdf
04-10
C++基础入门 C++是一种功能强大且灵活的编程语言，本文档旨在为读者提供一个基本的C++基础知识入门指南，包括创建项目、编写代码、运行程序、注释、变量、常量、关键字、标识符命名规则和数据类型等方面的知识点。 ...
C++入门，C++基础
06-07
本压缩包文件提供了丰富的C++学习资料，涵盖了从入门到进阶的关键知识点。 首先，"C++开始"部分是初学者接触这门语言的第一步，它会介绍C++的历史、特点以及如何安装编译环境，如GCC或Clang。这部分还会讲解基本的...
C++基础入门讲义md
07-16
非常详尽的C++入门讲义，很适合初学者
C++基础入门.md
11-21
C++基础入门.md、C++基础入门.md、C++基础入门.md 一提到这个名字相信有需要的小伙伴瞬间就能明白了，打开的话用typora这个软件，特别好，不认识名字的朋友也不要紧 这就是一个C++编程文档，很实用的，里边有一些C++...
C＋＋入门基础教程.PDF
04-03
C＋＋入门基础教程.PDF
c++中局部变量和全局变量同名，使用::访问全局变量
weixin_43845922的博客
11-02 197
局部变量可以与全局变量同名，在函数内引用这个变量时，会用到同名的局部变量，而不会用到全局变量。于有些编译器而言，在同一个函数内可以定义多个同名的局部变量，比如在两个循环体内都定义一个同名的局。答：能，局部会屏蔽全局。要用全局变量，需要使用”::”部变量，而那个局部变量的作用域就在那个循环体内。局部变量能否和全局变量重名？
Camp4-L0：Linux 前置基础
fangsfdavid的博客
10-29 875
书生浦语大模型实战营第四期：Linux前置基础
【C语言】预处理(预编译)详解(下)（C语言最终篇）
hdxbufcbjuhg的博客
10-29 2225
在编译⼀个程序的时候我们如果要将⼀条语句（⼀组语句）编译或者放弃编译，就可以使用条件编译，比如调试性的代码删掉很浪费，保留又很碍事，我们就可以使用条件编译，在编译的时候不编译这些调试性的代码在这里我们就可以使用一个技巧，在最开头使用#define定义一个符号，如果我们没有注释或者删除这个符号，那么我们就可以编译里面的调试性代码，进行正常调试，如果我们注释或者删除这个符号，那么我们就不编译里面的调试性代码，不影响代码的正常运行。
C++编程法则365天一天一条（344）理解std::optional的设计初衷
二进制君
11-02 40
的设计初衷是为了解决处理可选值时的安全性和清晰性问题，提供一种简洁、易用的方式来表示和管理可能不存在的值。通过引入，C++ 提供了一个更现代化的替代方案，减少了使用传统空指针和特定标记值所带来的复杂性和错误风险。
第20课-C++【二叉搜索树】
2401_83603768的博客
10-25 1155
二叉搜索树（Binary search tree）是一种特殊的二叉树，它的每个节点的左子树中的所有节点值都小于该节点值，而右子树中的所有节点值都大于该节点值。
C语言之长整型有符号数与短整型有符号数转换
qq_40939768的博客
10-29 710
最近考证的新星，问了一个问题：int a = 1234565789;为什么在输出%hd时的值为-1379？其实这个很简单，只不过对于可能初入“编程坑”以及经验不是很丰富的朋友来说，感觉知道这么个道理，但就是解释不上来，无法做出实际的推论。作者想说的是，这个知识点亦涉及多方面，比较广泛，所以就以咱们未来的新星所提的问题进行分析。
C++ -- 模板进阶
最新发布
zy1215058242的博客
11-02 539
一个程序/项目由若干源文件共同实现，而每个源文件单独编译生成目标文件，最后将所有目标文件链接起来形成单一的可执行文件的过程称为分离编译模式。模板复用了代码，节省资源，更快的迭代开发，C++的标准模板库(STL)因此而产生。增强了代码的灵活性。模板会导致会导致代码代码膨胀问题，也会导致编译时间变长。出现模板编译错误时，错误信息非常凌乱，不易定位错误。
C++朝花夕拾
weixin_44155149的博客
10-30 1054
1.从文件中按行读取数据，getline有很多版本，fstream的getline，std命名空间下的getline研究用法太麻烦，以后暂时统一使用std命名空间下的getline(文件流 ，std::string )SheepTuo(羊驼)从Sheep（羊）类继承了一个vbptr(虚基类指针)，从 Tuo（驼）类也继承了一个vbptr(虚基类指针),这两个指针分别指向一张虚基类表，表中有一个偏移量。本质:引用的本质在C++内部实现是一个指针常量(不可以修改指针的指向，但可以修改指向的值)
力扣——另一个的子树（C语言）
2401_83456040的博客
10-30 184
原理：这里调用前面比较两颗树是否相同的函数（小编之前文章里面有：相同的树），将节点与subRoot传入函数，向下递归，左右节点，只要找到一个返回true，说明存在子树，即最后返回true。具有相同结构和节点值的子树。的某个节点和这个节点的所有后代节点。也可以看做它自身的一棵子树。
C语言用GNU源码编译建构系统工具（GNU BUILD SYSTEM）编译创建源码包
gwsong52的博客
10-30 820
C语言用GNU源码编译建构系统工具（GNU BUILD SYSTEM）编译创建源码包，Makefile.am配置文件的编写、autoconf、configure、make等工具的用法。
yolov8训练及测试（ubuntu18.04、tensorrt、ros)
weixin_45702256的博客
10-30 445
数据集制作训练及测试
【C++】string 类模拟实现：深入探索字符串操作原理
A Charmer 的博客
11-01 890
本文详细介绍了 C++中模拟实现 string 类。从 string 类的功能需求入手，涵盖存储字符串、获取长度、比较、连接、修改和内存管理等方面。阐述了 MyString 类的定义及各函数实现，包括构造函数、析构函数、多种操作函数及内存管理函数。代码均有注释，易于理解。通过对每个函数的解析，让读者深入了解字符串处理原理。文末提供了 main 函数示例展示用法。这有助于读者掌握模拟 string 类的应用，提升 C++编程技能，更好地理解字符串操作背后的机制。
c加加11第一弹~
2301_81230745的博客
10-30 941
在C++98中的普通引用与const引用在引用实体上的区别int main()// 普通类型引用只能引用左值，不能引用右值int a = 10;// ra为a的别名// 编译失败，因为10是右值return 0;
C++ 游戏开发快速入门
wuzigege666的博客
10-29 569
通过本文，你应该已经对 C++ 游戏开发有了基本的了解，并能够创建一个简单的游戏项目。C++ 的强大之处在于它的性能和灵活性，无论是简单的 2D 游戏还是复杂的 3D 游戏，C++ 都能提供强大的支持。希望这篇文章对你有所帮助，祝你在 C++ 游戏开发的道路上一切顺利！
C++入门基础：从谭浩强的经典解析开始
"谭浩强__C++入门基础" C++是一种强大的编程语言，它起源于C语言，并在C的基础上增加了面向对象编程的概念。谭浩强的《C++入门基础》是一本适合初学者的教材，旨在帮助读者掌握C++的基本知识和编程技巧。 1. C++的...
评论 22
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值