C++入门知识点总结（上篇·初学必看）

最新推荐文章于 2024-10-08 06:04:53 发布

心跳sy

最新推荐文章于 2024-10-08 06:04:53 发布

阅读量914

点赞数 47

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

本文链接：https://blog.csdn.net/m0_74475605/article/details/140898197

版权

前言：Hello大家好😘，我是心跳sy，从今天开始我们走进C++的学习之路，本系列文章将会更新关于C++的全部初阶以及进阶的知识点，喜欢的小伙伴点个关注不迷路哦~我们一起来看看吧~

🌈心跳sy的C语言专栏 ⏪C语言知识点汇总到这了，有兴趣的友友可以订阅看看哟~💞💞💞

一、C++关键字 💫

👉C++关键字随着标准的更新，不断的增加和修改一些关键字的用法，我们不需要刻意记忆，在以后的学习之路中会慢慢了解它们的用法，我们大致看一下关键字的主流分类：

🔸1. 类型关键字：用来定义变量、函数返回类型等。例如：int, char, float, double, bool。

🔸2. 控制流关键字：用于控制程序的执行流程。例如：if, else, switch, case, for, while, do, break, continue, goto。

🔸3. 函数相关关键字：用于定义和声明函数。例如：return, inline, friend, virtual, override, final。

🔸4. 类和继承关键字：用于类及类的成员的声明和定义，以及类的继承。例如：class, struct, public, private, protected, static, const, volatile。

🔸5. 模板和异常处理关键字：用于泛型编程和异常处理。例如：template, try, catch, throw。

🔸6. 类型修饰符和低级操作关键字：用于修饰类型或进行低级操作。例如：new, delete, static_cast, dynamic_cast, const_cast, reinterpret_cast。

🔸7. 并发支持关键字：从C++11标准开始引入，用于支持多线程编程。例如：thread_local, constexpr, nullptr。

🔸8. C++11及其之后版本引入的关键字：为语言引入了新的特性和改进。例如：auto, decltype, noexcept, nullptr, constexpr, lambda表达式（如[], ->*等），concept（C++20）。

🔶注意，随着C++标准的更新，可能会有新的关键字被加入，或现有关键字的用途可能会有所变化，需要我们不断学习和积累。

二、命名空间 💫

🔶C++命名空间（Namespace）是C++的一个重要特性，它被设计用来解决代码命名冲突的问题，使得不同的开发者或库可以使用相同的标识符而不会发生冲突；命名空间可以包含函数、对象和类型声明。

2.1、⭐️为什么要使用命名空间？⭐️

👉在之前学习C语言时，我们有时会碰到这样的问题：

#include<stdio.h>
#include<stdlib.h>

int rand = 10;

int main()
{
	printf("%d\n", rand);//猜猜可以运行成功吗？
	return 0;
}

👉可以看到出现了问题，rand出现了重定义，之前的定义是“函数”，这时因为我们包了 stdlib.h 这个头文件，这个头文件里已经定义包含了 rand 这个函数，所以我们不能再定义并调用它。

👉面对这种情况，C语言只能暴力更改变量名，而无法灵活解决命名冲突的问题，在C++中，出现了使用命名空间对标识符的名称进行本地化，以避免命名冲突或名字污染，namespace关键字的出现就是针对这种问题的。

2.2、⭐️命名空间的语法⭐️

⭕️定义命名空间，需要使用到 namespace关键字，后面跟命名空间的名字，然后接一对 { } 即可，{ } 中即为命名空间的成员；语法如下：

namespace namespace_name 
{
    // ...声明、定义...
}

👉许多同学可以看书本映入眼帘的使用命名空间是

using namespace std;

⭕️这是标准库命名空间的展开，之后使用标准库中的函数都不需要添加域作用限定符（::），直接使用；C++标准库（STL）的所有组件（如最常用的输入输出，下面会介绍）几乎都放置在 std 命名空间中，在进行一些日常小练习时经常使用这种展开方式，方便后面的调用，但是在进行大项目制作时不可使用，极易造成冲突。

2.3、⭐️命名空间的定义和使用⭐️

🔶1、最简单的命名空间定义方式

namespace myNamespace
{
    int var = 5;
    void myFunction() 
    {
        // ...函数体...
    }
}

🔴注意命名空间中可以定义变量、函数、结构体类型，如下例中定义命名空间sy：

#include<iostream>
namespace sy
{
	// 命名空间中可以定义变量/函数/类型
	int rand = 10;

	int Add(int left, int right)
	{
		return left + right;
	}

	struct Node
	{
		struct Node* next;
		int val;
	};
}

🔸使用方式：加命名空间名称及作用域限定符（::） 需要特别注意结构体的命名空间使用方法，需在struct后使用命名空间域。（在这里输出先使用C语言的printf【因为C++兼容C】，后面将学习使用cout和cin，两种方法的代码可以相互替换）

int main()
{
	printf("%d\n", sy::rand);
	printf("%d\n", sy::Add(1, 2));
	struct sy::Node phead;
	return 0;
}

👉输出如下：

🍀插叙编译器搜索原则：

👉不指定域：1、当前局部域 2、全局域

👉指定域： 3、如果指定了域，直接去指定域搜索（使用域作用限定符::）

🔶2、命名空间可以嵌套定义，常出现在一个公司中需要容纳多个不同程序员定义的内容


 namespace sy
{
	namespace zs
	{
		void Push()
		{
			printf("zs\n");
		}
	}

	namespace ls
	{
		void Push()
		{
			printf("ls");
		}
	}
}

🔸对应的使用方法：先包大域，后加小域

int main()
{

	sy::zs::Push();
	sy::ls::Push();

	return 0;
}

⭕️两个特殊使用方法：

🔸1、命名空间使用的方式还有使用 using 将命名空间中某个成员引入，如下将 a 引入，相当于公开了a，在调用a时就不需要添加域作用限定符了，但b仍然需要。

namespace N
{
	
	int a = 0;
	int b = 1;
	int Add(int left, int right)
	{
		return left + right;
	}
	struct Node
	{
		struct Node* next;
		int val;
	};
}

using N::a;//使用using将命名空间中某个成员引入

int main()
{
	printf("%d\n", a);//输出0
	printf("%d\n", N::b);//输出1
	return 0;
}

🔸2、使用 using namespace 命名空间+名称引入（此时等于公开N命名空间内的所有成员，在main函数中均可直接调用，也可正常输出）

namespace N
{
	
	int a = 0;
	int b = 1;
	int Add(int left, int right)
	{
		return left + right;
	}
	struct Node
	{
		struct Node* next;
		int val;
	};
}

using namespace N;//使用using namespace 命名空间+名称 引入


int main()
{
	printf("%d\n", a);//输出0
	printf("%d\n", b);//输出1
	return 0;
}

🔶3、若在同一个工程中允许存在多个相同名称的命名空间，编译器最后会合成同一个命名空间中。

三、C++输入和输出 💫

3.1、⭐️基本概念梳理⭐️

🔸在C语言中，我们通过调用 printf 和 scanf 函数来实现输入和输出，

🔸在C++中，通过调用输入输出库中的流对象 cin 和 cout 来实现输入和输出；

输入和输出操作主要通过流来实现，cout是输出流对象的名字，cin是输入流对象的名字；“<<”是流插入运算符，其作用是将需要输出的内容插入到输出流中（默认显示器），“>>”是流提取运算符，用于从默认输入设备（一般为键盘）的输入流中提取若干字节送到计算机内存区中指定的变量。

🌸需要注意的是，如果在程序中使用cin、cout和流运算符，就必须包括头文件#include<iostream> 和标准库命名空间的展开（using namespace std），关于命名空间不懂的宝子可以看看上面的介绍~

👉下例输出Hello world!!!：

#include<iostream>
// std是C++标准库的命名空间名，C++将标准库的定义实现都放到这个命名空间中
using namespace std;
int main()
{
cout<<"Hello world!!!"<<endl;//与printf显示效果一样
return 0;
}

3.2、⭐️输入流和输出流的基本用法⭐️

🔶cout 语句的一般格式为：

cout<<表达式1<<表达式2<<......<<表达式n;

🔶cin语句的一般格式为：

cin>>变量1>>变量2>>......>>变量n;

👉上面例子中的 endl 是换行的意思，和C语言中的 ‘\n’ 是有异曲同工之妙的，二者可以相互替代，但一般在C++中我们更习惯使用endl来换行；下面来看一个具体实例：

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

    // 可以自动识别变量的类型
    cin >> a;
    cin >> b >> c;

    cout << endl;
    cout << a << endl;
    cout << b << " " << c << endl;
    return 0;
}

⭕️在C++中，输入输出可以自动识别变量的类型，cin的连续输入可以一行输入（以空格分离），也可以多行输入，如上面输入方式，输出方式按照自己的喜好来就好了。

⭕️关于 cout 和 cin 还有很多更复杂的用法，比如控制浮点数输出精度，控制整形输出进制格式等，由于这部分是入门学习，复杂的就先不讲啦，后续学习中会在I/O流中详细介绍C++的输入输出难点~

四、缺省参数 💫

4.1、⭐️概念理解⭐️

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

void Func(int a = 0)
{
 cout<<a<<endl;
}

int main()
{
 Func();     // 没有传参时，使用参数的默认值0
 Func(10);   // 传参时，使用指定的实参10
 return 0;
}

4.2、⭐️缺省参数的分类⭐️

🌈全缺省参数

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

int main()
{
	Func(1, 2, 3);
	Func(1, 2);
	Func(1);
	Func();

	return 0;
}

🔴上图输出结果遵守该规则： 如果没有指定实参则采用该形参的缺省值，否则使用指定的实参

🌈半缺省参数（下例此时由于最左边未给出形参缺省值，所以在调用时至少有一个a对应的指定实参）

// 半缺省 从右往左连续给
void Func(int a, int b = 20, int c = 30)
{
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	cout << "c = " << c << endl << endl;
}

int main()
{
	Func(1, 2, 3);
	Func(1, 2);
	Func(1);

	return 0;
}

🔴输出结果仍然遵守上面的规则，还有不清楚的小伙伴可以自己动手验证一下加深记忆理解哦~

🔴注意：

1. 半缺省参数（见例子的形参给出顺序）必须从右往左依次来给出，不能间隔着给；

2. 缺省参数不能在函数声明和定义中同时出现，若程序将声明和定义分离，只在声明中给出即可；

3. 缺省值必须是常量或者全局变量；

4. 缺省参数是对C语言传参的弥补，所以在C语言中不支持（编译器不支持）

五、函数重载 💫

5.1、⭐️概念理解⭐️

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

🔶C语言不支持重载，链接时直接用函数名去找地址，有同名函数，导致区分不开；C++中进行了优化，函数名修饰规则，名字中引入参数类型，只要参数不同，修饰出来的名字就不一样，就支持了重载，各个编译器自己实现了一套规则；

5.2、⭐️函数重载的规则⭐️

1. 不同的参数列表：重载函数的参数列表必须有所不同。这可以是参数个数不同、参数类型不同，或者参数的顺序不同（本质还是类型不同）。

2. 返回类型不是重载依据：函数的返回类型不能作为重载的依据。也就是说，仅返回类型不同的同名函数是不能构成函数重载的。

5.3、⭐️实例理解⭐️

🔸参数类型不同

// 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;
}

🔸参数个数不同

void f()
{
 cout << "f()" << endl;
}
void f(int a)
{
 cout << "f(int a)" << endl;
}

🔸参数类型顺序不同

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;
}

本文到此结束💞💞💞感谢大家花费宝贵的时间阅读本文章，制作不易，希望大家多多支持呀😘😘😘，如有任何问题欢迎各位大佬在评论区批评指正！！！

心跳sy

关注

47
点赞
踩
39

收藏

觉得还不错? 一键收藏
36
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫