【C++】 C++入门(上)

最新推荐文章于 2024-08-15 05:02:54 发布

hhhc.

最新推荐文章于 2024-08-15 05:02:54 发布

阅读量126

点赞数 1

文章标签： c++ 开发语言

本文链接：https://blog.csdn.net/m0_66054454/article/details/130175168

版权

本文介绍了C++中的关键字，如asmdoif等，并讲解了命名空间的作用和定义方式，以及如何避免命名冲突。接着，讨论了C++的输入输出机制，如使用cout和cin，以及它们与C语言printf/scanf的区别。此外，文章还涵盖了函数的缺省参数和重载，以及引用的概念、特性，包括常引用和引用在函数参数及返回值中的应用。最后，对比了引用与指针的异同，强调了引用的安全性和效率优势。

摘要由CSDN通过智能技术生成

1. C++的关键字

C++总计63个关键字，C语言32个关键字。

asm	do	if	return	try	continue
auto	double	inline	short	typedef	for
bool	dynamic_cast	int	signed	typeid	public
break	else	long	sizeof	typename	throw
case	enum	mutable	static	union	wchar_t
catch	explicit	namespace	static_cast	unsigned	default
char	export	new	struct	using	friend
class	extern	operator	switch	virtual	register
const	false	private	template	void	true
const_cast	float	protected	this	volatile	while
delete	goto	reinterpret_cast

2. 命名空间

在C/C++中，变量、函数和后面要学到的类都是大量存在的，这些变量、函数和类的名称将都存在于全局作用域中，可能会导致很多冲突。使用命名空间的目的是对标识符的名称进行本地化，以避免命名冲突或名字污染，namespace关键字的出现就是针对这种问题的。

命名空间的定义：

定义命名空间，需要使用到namespace关键字，后面跟命名空间的名字，然后接一对{}即可，{}中即为命名空间的成员。

namespace n1
{
     int a = 10;
     char b = 'h';
}

例如上面的代码就是定义了一个叫做n1的命名空间，里面包含a,b两个变量。

3. C++的输入和输出

1. 使用cout标准输出对象(控制台)和cin标准输入对象(键盘)时，必须包含< iostream >头文件以及按命名空间使用方法使用std。
2. cout和cin是全局的流对象，endl是特殊的C++符号，表示换行输出，他们都包含在包含< iostream >头文件中。
3. <<是流插入运算符，>>是流提取运算符。
4. 使用C++输入输出更方便，不需要像printf/scanf输入输出时那样，需要手动控制格式。C++的输入输出可以自动识别变量类型。
5. 实际上cout和cin分别是ostream和istream类型的对象，>>和<<也涉及运算符重载等知识，这些知识我们我们后续才会学习，所以我们这里只是简单学习他们的使用。后面我们还有有一个章节更深入的学习IO流用法及原理。
注意：早期标准库将所有功能在全局域中实现，声明在.h后缀的头文件中，使用时只需包含对应头文件即可，后来将其实现在std命名空间下，为了和C头文件区分，也为了正确使用命名空间，规定C++头文件不带.h；旧编译器(vc 6.0)中还支持<iostream.h>格式，后续编译器已不支持，因此推荐使用<iostream>+std的方式。

#include<iostream>
using namespace std;
int main()
{
	int a;
	double b;
	char c;
	cin >> a;
	cin >> b;
	cin >> c;
	cout << endl;
	cout << a << endl;
	cout << b << endl;
	cout << c << endl;
}

输入输出的内容编译器可自动识别类型。

4. 缺省函数

缺省参数是声明或定义函数时为函数的参数指定一个缺省值。在调用该函数时，如果没有指定实参则采用该形参的缺省值，否则使用指定的实参。

void func(int a = 10)
{
	cout << a << endl;
}

int main()
{
	func();
	func(15);
}
这个里的给出的函数参数是10，挡当在main函数中直接调用的话，就是默认的参数值给10。

缺省函数的分类

1.全缺省函数

void Func(int a = 10, int b = 20, int c = 30)
{
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	cout << "c = " << c << endl;
}

int  main()
{
	Func();
	return 0;
}

2. 半缺省函数

void Func(int a = 10, int b = 20, int c = 30)
{
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	cout << "c = " << c << endl;
}

int  main()
{
	Func(15,25);
	return 0;
}

注意：

1. 半缺省参数必须从右往左依次来给出，不能间隔着给
2. 缺省参数不能在函数声明和定义中同时出现
3. 缺省值必须是常量或者全局变量
4. C语言不支持（编译器不支持

5.函数重载

函数重载：是函数的一种特殊情况，C++允许在同一作用域中声明几个功能类似的同名函数，这些同名函数的形参列表(参数个数或类型或类型顺序)不同，常用来处理实现功能类似数据类型不同的问题。


#include<iostream>
using namespace std;

// 1、参数类型不同
int Add(int left, int right)
{
	cout << "int Add(int left, int right)" << endl;
	return left + right;
}
double Add(double left, double right)
{
	cout << "double Add(double left, double right)" << endl;
	return left + right;
}
// 2、参数个数不同
void f()
{
	cout << "f()" << endl;
}
void f(int a)
{
	cout << "f(int a)" << endl;
}
// 3、参数类型顺序不同
void f(int a, char b)
{
	cout << "f(int a,char b)" << endl;
}
void f(char b, int a)
{
	cout << "f(char b, int a)" << endl;
}
int main()
{
	Add(10, 20);
	Add(10.1, 20.2);
	f();
	f(10);
	f(10, 'a');
	f('a', 10);
	return 0;
}

6. 引用

6.1 引用概念

引用不是新定义一个变量，而是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间。
引用的类型必须与引用的实体的类型一致。

void TestRef()
{
int a = 10;
int& ra = a;//<====定义引用类型
printf("%p\n", &a);
printf("%p\n", &ra);
}

6.2 引用特性

1. 引用在定义时必须初始化
2. 一个变量可以有多个引用
3. 引用一旦引用一个实体，再不能引用其他实体

void TestRef()
{
int a = 10;
// int& ra; // 该条语句编译时会出错，因为应该未初始化
int& ra = a;
int& rra = a;
printf("%p %p %p\n", &a, &ra, &rra);
//打印的三个值都是一样，以为这三个都是对同一个变量的引用
}

6.3 常引用

int main()
{
	// 不可以
	// 引用过程中，权限不能放大
	const int a = 0;
	//int& b = a;  const的权限小

	// 可以，c拷贝给d，没有放大权限，因为d的改变不影响c
	const int c = 0;
	int d = c;

	// 不可以
	// 引用过程中，权限可以平移或者缩小
	int x = 0;
	int& y = x;
	const int& z = x;
	++x;
	//++z;  ++z不行，因为z的权限较小

	const int& m = 10;

	double dd = 1.11;
	int ii = dd;

	//int& rii = dd;   这里不可以是因为权限放大了
	const int& rii = dd;//这个对于变量类型来说是将rii存放到一个中间值，再将中间值赋值给dd，
	                    //加上const对于权限来说就是权限的平移
	return 0;
}

6.4 使用场景

1. 做参数

void Swap(int& left, int& right)
{
int temp = left;
left = right;
right = temp;
}

最典型的就是两个数值的互换。在C语言中需要通过指针，数组等来实现，但是引用的本身的性质是一个变量的别名，也就是说在函数中改变了这个值，到了main函数中它的值也会随之改变，而不只是形参是实参的一份拷贝。

2. 做返回值

int count()
{
	int n = 1;
	return n;
}
int main()
{
	int ret = count();
	return 0;
}
这一段代码非常的好理解，就是将count的函数的返回值放到ret中。

int& count2()
{
	int n = 0;
	n++;
	return n;
}
int main()
{
	int ret = count2();
	cout << ret << endl;
	return 0;
}
这样一段代码看起来运行结果是1，实则是已经越界了。因为函数的返回值是引用类型，有了&符号，只是这个临时变量的类型是int&，这个过程就是相当于将n的值赋值给ret，这里区分与传值返回的核心就是传引用的返回就是n的别名。

然而对于出了count2函数的时候，需要将函数栈帧进行销毁，n的值也就销毁了，n就是ret的别名，这样ret的值将会是一个随机值，但是这里的结果却依然是1.

这里结果运行还是1的原因是函数栈帧已经销毁，但是函数栈帧却没有清理，这时的ret的值它时1也是侥幸的，如果说再去调用一个函数，将栈帧再次开辟一下，那么这里的运行结果将会是随机值。
int& count2(int x)
{
	int n = x;
	n++;
	return n;
}
int main()
{
	
	int& ret = count2(10);
	cout << ret << endl;
	count2(20);
	cout << ret << endl;
	return 0;
}
对于这样一个代码，第一是因为侥幸打印出了11，第二次打印前先调用了一个函数将栈帧给重置了，同样打印的都是ret但是它的值却不一样了。

如果非要使用引用的返回值呢？

那么在这里就可以加上static来实现。
int& count2(int x)
{
	static int n = x;
	n++;
	return n;
}
int main()
{
	
	int& ret = count2(10);
	cout << ret << endl;
	count2(20);
	cout << ret << endl;
	return 0;
}
加上static之后，此时的n在静态去而非是栈，那么函数调用完销毁后，n的值不会因此而销毁，所以打印的值就是11，12.

6.5 传值和传引用的效率

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

#include <time.h>
struct A { int a[10000]; };
void TestFunc1(A a) {}
void TestFunc2(A& a) {}
void TestRefAndValue()
{
	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 < 10000000; ++i)
		TestFunc2(a);
	size_t end2 = clock();
	// 分别计算两个函数运行结束后的时间
	cout << "TestFunc1(A)-time:" << end1 - begin1 << endl;
	cout << "TestFunc2(A&)-time:" << end2 - begin2 << endl;
}
int main()
{
	TestRefAndValue();
	return 0;
}

6.6 引用和指针的区别

在语法概念上引用就是一个别名，没有独立空间，和其引用实体共用同一块空间。

在底层实现上实际是有空间的，因为引用是按照指针方式来实现的。

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