《C++入门篇》

偷懒下载原神

已于 2025-05-16 10:02:07 修改

阅读量778

点赞数 21

CC 4.0 BY-SA版权

分类专栏： C++ 文章标签： c++ 开发语言

于 2025-03-13 23:25:14 首次发布

本文链接：https://blog.youkuaiyun.com/lzk666_csdn/article/details/146242887

C++ 专栏收录该内容

11 篇文章

订阅专栏

从今天开始俺将发布有关c++的学习内容，还请各位大佬指正。

第一个C++程序

我们写c语言是从helloworld开始的，c++同样可以这样。

#include<iostream>
using namespace std;
int main()
{
	cout << "hello world!" << endl;
	return 0;
}

哎，此时此刻你心中一定有很多疑惑，我知道你很急，但是你先别急，且听我道来。

命名空间

关键字：namespace，定义：namespace后面跟上命名空间名即可。命名空间实际上是一个域，c++中有函数局部域，全局域，命名空间域，类域。c++规定在不同的域中可以定义同名变量/函数/类型，这样就避免了同名数据冲突的问题。本质是命名空间域和类域影响了编译查找的逻辑。namespce只能定义在全局，可以嵌套定义。c++标准库都放在一个名为std的命名空间中。使用命名空间中的变量/函数/类型需要使用：：符号。

输入与输出

在第一个C++程序中第一行代码写的是#include<iostream>。什么意思呢？实际上就是对输入输出函数的一种声明。c++中cout即是输出将数据展示到电脑屏幕上，对应的符号为<<，cin即是输入从键盘上读取数据给系统，对应的符号为>>。无需格式化输入与输出。

下面给出代码体会一下

 //命名空间 

namespace bit
{
	//定义变量
	//不同的域中可以定义同名变量
	int rand = 10;
	int a = 199;
	double d = 3.14;
	float f = 3.14f;
	//函数
	int add(int left, int right)
	{
		return right + left;
	}
	//结构体
	struct Node
	{
		struct Node* next;
		int a = 0;
	};

	//命名空间的嵌套
	namespace kg
	{
		int rand = 0;
	}
	namespace lzk
	{
		int rand = 3;
	}
}
//将命名空间中的变量单独展开
using bit::a;

int main()
{
	int ret = bit::add(1, 3);
	cout << ret << endl;

	//打印不同域中的同名变量的地址，结果不一样
	cout << &rand << endl;
	cout << &bit::rand << endl;
	//打印嵌套命名空间中的同名变量
	cout << bit::kg::rand << endl;
	cout << bit::lzk::rand << endl;
	//打印命名空间展开的变量
	cout << a << endl;
	//自动识别变量类型并打印
	cout << bit::d << endl;
	cout << bit::f << endl;
	
	return 0;
}

缺省参数

在声明或定义函数时，为函数的参数指定一个缺省值（如果声明和定义在程序中同出现且要指定缺省值，则只能在声明中指定）。在调用函数时如果有实参则形参使用实参的值，如果没有实参则使用缺省值。全缺省，顾名思义，就是形参全部都有缺省值，半缺省，就是只给了部分形参的缺省值。给实参必须从左向右依次给，给缺省值必须从右向左给。

给段代码体现一下

//缺省参数

//全缺省
void func1(int a = 99, int b = 98, double c = 3.14)
{
	cout << a << endl;
	cout << b << endl;
	cout << c << endl;
}
//半缺省
//void func2(int a, int b = 97, double c)必须从右向左依次缺省
//void func2(int a = 0, int b = 97, double c )erro
void func2(int a, int b = 97, double c = 3.14)
{
	cout << a << endl;
	cout << b << endl;
	cout << c << endl;
}

int main()
{
	func1();//没给参数自动使用缺省值
	func2(100,101,3.14);//传参使用参数值
	func1(96, 94, 92);//从左向右依次给实参，不能跳跃着给

	return 0;
}
//缺省参数不能函数声明和定义同时给，两者同时出现的时候只能单独给声明缺省值

函数重载

c++支持在同一域中出现同名函数，但是它们的形参必须不同。

给段代码体会下

//函数重载
//c++中支持同名函数，但是要求同名函数的参数类型不同

//参数类型不同
int add(int a, int b)
{
	cout << "int add(int a, int b)" << endl;
	return a + b;
}
double add(double a, double b)
{
	cout << "double add(double a, double b)" << endl;
	return a + b;
}

//参数类型顺序不同
int add(int a, double b)
{
	cout << "int add(int a, double b)" << endl;
	return a + b;
}
int add(double b, int a)
{
	cout << "int add(double b, int a)" << endl;
	return a+b;
}

//参数个数不同
int add(int a, int b, int c)
{
	cout << "int add(int a, int b, int c)" << endl;
	return a + b + c;
}
int add(int a)
{
	cout << "int add(int a)" << endl;
	return a;
}

//函数参数相同，返回值类型不同不能作为函数重载
//int add(double a, double b, double c)
//{
//	??????
//}
//double add(double a, double b, double c)
//{
//  ??????
//}


//构成函数重载，但是函数调用的时候会有歧义
//int func1()
//{
//	cout << "int func1()" << endl;
//	return 0;
//}
//int func1(int a = 10)   给定一个缺省参数
//{
//	cout << "int fouc1(int a)" << endl;
//	return a;
//}

int main()
{
	add(1, 2);
	add(1.1, 2.2);
	add(1, 1.1);
	add(1.1, 1);
	add(1, 2, 3);
	add(1);
	/*func1();*/
	return 0;
}

引用

含义：给变量取别名，但是还是指向同一块空间。符号：&，使用：在要引用的对象类型后面加&，如要引用一个int类型的对象就是int&。引用实际上和c语言中的指针很像，但是不完全一样。

注意const引用的权限问题，下面代码中会提到。

区别：

● 引用不额外开辟空间，指针开辟

● 引用在定义时必须初始化，指针不做要求

● 引用在指定一个对象后不能改变，指针可以改变

● 引用直接访问指向的对象，指针需要解引用

● sizeof引用，结果为引用类型大小，sizeof指针，结果为地址大小

来段代码体会一下

//引用
int main()
{
	int a = 0;
	int& b = a;
	int& c = a;
	//引用必须初始化
	//int& d;
	int& d = b;
	int e = 10;
	d = e;//不是让d引用e而是用e给d赋值
	++c;
	d++;
	cout << a << endl;
	cout << b << endl;
	cout << c << endl;
	cout << &a << endl;
	cout << &b << endl;
	cout << &c << endl;
	cout << &d << endl;
	//无法引用常变量
	//int& g = 1;
	return 0;
}


//引用传参
//const引用
void swap(int& rx, int& ry)
{
	int tmp = rx;
	rx = ry;
	ry = tmp;
}

//引用返回
int& add(int x, int y)
{
	int ret = x + y;
	return ret;//ret在函数结束后被系统回收导致空引用
}

int main()
{

	int x = 1;
	//int& a = x * 2;等号右边为表达式，c++将其结果储存在一个临时变量中，而c++规定临时变量具有常性
	const int& a = x * 2;//才可以
	cout << a << endl;
	cout << sizeof(a) << endl;
	double y = 3.14;
	//int& b = y;//类型转化中会产生临时对象储存中间值，也具有常性
	//const int& b = y;才可以
	double& b = y;
	cout << b << endl;
	cout << sizeof(b) << endl;//引用的sizeof的结果是引用类型的大小

	int r = add(1, 2);
	cout << r << endl;

	

	//int& a = x;扩大了使用权限不行
	const int& a = x;
	//a++;//无法改变常量
	int y = 1;
	const int& b = y;//缩小使用权限可以
	//b++;//无法改变常变量
	cout << y << endl;
	cout << b << endl;
	y++;
	cout << y << endl;
	cout << b << endl;
	
	
	
	/*swap(x, y);
	cout << x << " " << y << endl;
	swap(x, y);
	cout << x << " " << y << endl;*/
	return 0;
}

inline内联

被inline修饰的函数叫内联函数。函数被修饰后，在调用时不会建立栈帧，会在调用的地方直接展开，但是inline对c++编译器只是一个建议，使不使用取决于编译器。函数短小且需要频繁调用，此时应用inline修饰。不能将inline函数声明和定义分开到两个文件。

nullptr

nullptr是一个关键字，它可以（只能）转换成任意类型的指针类型。使用nullptr，避免了NULL会被转换成0的情况。

如下

//nullptr
void f1(int x)
{
	cout << "void f1(int x)" << endl;

}

void f1(int* ptr)
{
	cout << "void f1(int* ptr)" << endl;
}

int main()
{
	f1(0);
	f1(NULL);//NULL被定义成了0
	f1((int*)NULL);//强制类型转换

	f1(nullptr);//只能是指针类型
 }

看到此处你的c++浅浅入门，更精彩的还在后面。看没看懂都点个赞呗。