[C++]C++入门到入土篇 HelloWorld 解析 && C++入门 _Helloworld

智慧并不产生于学历,而是来自对于知识的终生不懈的追求。这篇文章主要讲述[C++]C++入门到入土篇 HelloWorld 解析 && C++入门相关的知识，希望能为你提供帮助。

在之前，我已经学完了C语言，数据结构初阶（C实现）。从本篇博客开始，正式进入C++的学习历程。C++的学习要结合之前C语言以及数据结构的知识，在学习C++的过程中顺便复习巩固已经学过的知识。
愿自己能够持续努力，输出更多关于C++的优质文章。

通过看完本篇解决以下问题:
1. using namespace std；是什么意思？
2. 你了解命名空间吗？会使用吗？
3. < < 符号是什么？
4.函数重载是什么？使用有什么注意事项？

目录
1.HelloWorld的实现代码
2.C++关键字
3.命名空间 ?
4.C++输入和输出?
5.函数重载????

1.HelloWorld的实现代码（本篇看完就能知道每一行代表的意思）

#include < iostream>
using namespace std;

int main()

cout < < "hello world!" < < endl;
return 0;

结果显示：

2.C++关键字C++总计63个关键字，C语言32个关键字。以下就是C++所包含的关键字。这些关键字在我们后续的学习过程中都会涉及到，我们在以后遇到的时候会细细的分析。

3.命名空间 3.1问题引入1.我们在看过或者学过C++的小伙伴们都遇到过C++程序都会包括这个头文件

#include < iostream>

这个类似于我们C语言中的

#include < stdio.h>

这是用来和控制台进行输入和输出的。我们也可以使用C语言的这个头文件
2.那么这个是什么东西呢？

using namespace std;

我们发现其中包含了我们的一个关键字 namespace。这就是命名空间。这是对C语言的补充，那我们一起来了解一下namespace。
首先，我们都知道C语言中存在一个问题：命名冲突

#include < stdio.h>
//命名冲突
int a = 10; //第一个人
int a = 10; //第二个人
int main()

printf("%d\\n",a);
return 0;

我们运行发现明显了明显的命名冲突错误

同一个作用域中变量是不能出现重复的命名的，但是如果一个小组同时开发，不知道彼此使用什么命名，这时就可能就造成命名冲突。
此时C++就引入了namespace命名空间。

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

3.2命名空间的定义3.2.1 :: 域作用限定符

我们来看看这段代码，他的输出结果是多少？

#include < stdio.h>
int a = 0;
int main()

int a = 1;
printf("%d\\n", a); //局部a
return 0;

我们在C语言学习过知道这里肯定会输出 1,在之前作用域的学习过程中我们知道局部优先。

【[C++]C++入门到入土篇 HelloWorld 解析 && C++入门】

那么我现在就想访问全局的a,应该怎么办呢？

此时我们就要使用域作用限定符(::)，::这个符号叫做域作用限定符，他的功能是根据::左边的域找变量，如果左边空白就默认全局域

#include < stdio.h>
int a = 0;
int main()

int a = 1;
printf("%d\\n", a); //局部a
printf("%d\\n", ::a); //::域作用限定符全局a
return 0;

我们看输出结果发现拿到了全局的a

3.2.2命名空间的使用
如果我们要避免这个a变量的重复出现，这时就可以使用命名空间。
命名空间的格式：

//1. 普通的命名空间
namespace N1 // N1为命名空间的名称

// 命名空间中的内容，既可以定义变量，也可以定义函数
int a;
int Add(int left, int right)

return left + right;

//也可以定义类型
struct ListNode//可以定义类型

int val;
struct ListNode* next;
;

那么刚刚不同人写的两段代码我们就可以使用命名空间来包含起来：

#include < stdio.h>
//命名冲突
namespace N1

int a = 10; //第一个人

namespace N2

int a = 20; //第二个人

int main()

printf("%d\\n",N1::a);
return 0;

此时我们看到我们输入的是N1::a，这时我们就是拿到的N1空间域内部的a，如果我们想拿到N2空间域的a，N2::a就得到了这样的结果：

3.2.3命名空间的嵌套使用
命名空间也是可以嵌套使用的，结构如下：

namespace N2

int a;
int b;
int Add(int left, int right)

return left + right;

namespace N3

int c;
int d;
int Sub(int left, int right)

return left - right;

我们也举个例子方便理解：

//命名空间还可以嵌套使用
namespace lxy

int c = 1;
namespace data

//数据组
int d = 5;

namespace cache

//缓存组
int e = 10;

我们发现lxy下的空间内部又嵌套了data和cache，那使用的时候怎么使用其实也非常简单

注意：一个命名空间就定义了一个新的作用域，命名空间中的所有内容都局限于该命名空间中。

3.3命名空间的使用方式命名空间的使用有三种方式：
3.3.1加命名空间名称及作用域限定符
这就是我们刚刚一直所使用的方式，我们再看看其结构:

int main()

printf("%d\\n", N::a);
return 0;

3.3.2使用using将命名空间中成员引入
假设我们要经常使用某一个命名空间中的定义的东西，那我们每次使用的时候都要使用:: 我们发现这是很不方便的，因此我们使用using 就相当于把这个命名空间的作用域放开了。

namespace lxy

namespace data

//数据组
int d = 5;

using lxy::data::d;
int main()

printf("%d\\n", d);
return 0;

我们发现使用using lxy::data::d之后，我们发现主函数就可以直接使用d。
3.3.3使用using namespace 命名空间名称引入

namespace lxy

namespace data

//数据组
int d = 5;

using namespace lxy;
using namespace data;
int main()

printf("%d\\n", d);
return 0;

我们这样也是可以在main函数直接使用的。

因此我们可以回看helloworld程序中的第二行，我们就知道了这是放开了C++中标准库的命名空间。

#include < iostream>
using namespace std; //std 封C++库的命名空间

int main()

cout < < "hello world" < < std::endl;
return 0;

4.C++输入和输出这里先简单的了解一下C++的输入和输出，后续还会专门学习输入输出流。
我们先以这个helloworld为例来进行简单的了解：

#include < iostream>
using namespace std;
int main()

cout < < "hello world!" < < endl;
return 0;

在这里我们知道cin是输入，cout是输出，那其中的< < 和> > 又分别指的是什么呢？

答：> > 是流提取运算符，< < 流插入运算符。其中输入和输出都是可以输入多个和输出多个的。其中endl是换行符。其中在C语言中的\\n仍然是可以使用的。

说明：

1. 使用cout标准输出(控制台)和cin标准输入(键盘)时，必须包含< iostream > 头文件以及std标准命名空间。

注意：早期标准库将所有功能在全局域中实现，声明在.h后缀的头文件中，使用时只需包含对应头文件即可，后来将其实现在std命名空间下，为了和C头文件区分，也为了正确使用命名空间，规定C++头文件不带.h；旧编译器(vc 6.0)中还支持< iostream.h> 格式，后续编译器已不支持，因此推荐使用 < iostream> +std的方式。

2. 使用C++输入输出更方便，不需增加数据格式控制，比如：整形--%d，字符--%c

4.1缺省参数缺省参数在C语言中也是不支持的，它具体是什么？

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

我们举个例子可以看看：

////缺省参数
void TestFunc(int a = 0)

cout < < a < < endl;

int main()

TestFunc(); //没有参数时，是用参数的默认值
TestFunc(1);
return 0;

在这段代码中第一个TestFunc函数是没有传参的，在C语言中，这是显然错误的，但是在C++语言中如果函数有默认值，当函数不传参时，就会使用默认值。但是一旦传参，函数就会以传入的参数为准。因此缺省参数好比是一个备胎。

4.2缺省参数的分类4.2.1全缺省参数
全缺省参数就是每个参数都有默认值，因此可以都不传，不传参数就会使用默认值，但是如果要传参数，传入的参数必须是从左往右传，如果想跳过a，使用a的默认值，传b这是不可以的。

////全缺省
// 可以都不传,但是要传是从左往右传
void TestFunc(int a = 10, int b = 20, int c = 30)

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

int main()

TestFunc();
TestFunc(1);
TestFunc(1,2);
TestFunc(1, 2,3);
return 0;

运行结果：
4.2.2半缺省参数
半缺省参数就是必须至少传一个，并且按照顺序从左往右传。

void TestFunc(int a, int b = 20, int c = 30)

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

int main()

TestFunc(1);
TestFunc(1, 2);
TestFunc(1, 2, 3);
return 0;

此时我们观察上述代码：TestFunc函数的第一个参数a是没有默认值的，这时必须给a传值，否则就会出错。

半缺省参数在栈中的灵活使用：
我们知道栈的初始化要开辟空间，如果我们默认让栈的空间是4，如果我们不传参就使用默认的4个空间，如果我们想要多大，再传多大，这时我们就不用每次都需要开辟，我们只需要更改空间大小的参数值即可。

struct Stack

int* a;
int size;
int capacity;
;

void StackInit(struct Stack* ps, int n = 4)

assert(ps);
ps-> a = (int*)malloc(sizeof(int) * n);
ps-> size = 0;
ps-> capacity = n;

int main()

Stack st;
StackInit(& st, 100);
return 0;

5.函数重载5.1函数重载的概念

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

我们可以根据参数列表的不用选择同名但不同的函数进行调用。

int Add(int left, int right)

return left + right;

double Add(double left, double right)

return left + right;

int main()

cout < < Add(1, 2) < < endl;
cout < < Add(1.1, 2.2) < < endl;
return 0;

我们发现上述两个函数名都是Add,但是我们显然可以看成他们的参数类型是不同的，因此当我们传入不同的参数是就会进入对应数据类型的函数。这就是函数重载。

我们再举一个例子看看：
在这个例子中我们可以发现，他们的返回类型都是void，但是他们也属于函数重载，因为他们参数的顺序不同。

void f(int a, double b)

cout < < "void f(int a, double b)" < < endl;

void f(double a, int b)

cout < < "void f(double a, int b)" < < endl;

int main()

f(1, 22.22);
f(1.11, 2);
return 0;

5.2函数重载总结