初阶C++——C++第一节——C++基础语法

最新推荐文章于 2022-10-26 01:32:04 发布

jxwd

最新推荐文章于 2022-10-26 01:32:04 发布

阅读量949

点赞数 52

分类专栏：初学至学会C++ 文章标签： c++ 开发语言后端 c语言

本文链接：https://blog.csdn.net/xdnxl/article/details/122639445

版权

初学至学会C++ 专栏收录该内容

11 篇文章 56 订阅

订阅专栏

这下，我前面什么都不想写了，上来就是正文，上来就肝。没有广告了！

要说明一句，在C中啰嗦过的语法在这里是不可能重复了的（什么分支循环什么的），相信如果我要是重复啰嗦的话，我不烦你们都烦了。

一、什么是C++

二、C++的发展史

三、C++命名空间——关键字namespace

9-1-1 auto与指针和引用结合起来使用

9-1-2 在同一行定义多个变量

9-1-3 auto不可以作为函数的参数

9-1-4 auto不可直接用来声明数组

十、基于范围的for循环(C++11) （范围for）

范围for的使用条件

十一、指针空值nullptr(C++11)

注意事项：

一、什么是C++

框~一大段文字。。。。看看就行了。

C语言是结构化和模块化的语言，适合处理较小规模的程序。
对于复杂的问题，规模较大的程序，需要高度的抽象和建模时，C语言则不合适。
为了解决软件危机， 20世纪80年代，计算机界提出了OOP(objectoriented programming：面向对象)思想，支持面向对象的程序设计语言应运而生。
1982年，Bjarne Stroustrup博士在C语言的基础上引入并扩充了面向对象的概念，发明了一种新的程序语言。为了表达该语言与C语言的渊源关系，命名为C++。

因此：C++是基于C语言而产生的，它既可以进行C语言的过程化程序设计，又可以进行以抽象数据类型为特点的基于对象的程序设计，还可以进行面向对象的程序设计

二、C++的发展史

好，闲话说完，我们进入正题。

注：接下来的描述，如果不特殊强调，所指的都是C++98，C++11笔者会特殊强调

三、C++命名空间——关键字namespace

我们在学校写C++是不是经常有这么一句话：

using namespace std;

可是这句话是什么意思呢？

这里的namespace就是命名空间的意思。

C++把所有库的函数、类等（只要是库里的），都封装到了std这样一个命名空间中。所以，当我们想要调用输入输出流的cin和cout时，就必须先指名我们用到的是std这样一个命名空间里面的。

命名空间存在的意义正是在于当有相同的标识符并且作用不同的时候，把它们放在不同的命名空间里，就可以解决这样的问题。

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

不难理解。

3-1 命名空间的定义方法

——用namespace关键字，后面跟命名空间的名字，然后接一对{}即可，{}中即为命名空间的成员。我们后面在模拟实现STL的各个类的时候会用到这个东西。

我们来举几个例子吧：

namespace jxwd
{
    int a;
    int b;
    //...
}

同时，需要注意的是，命名空间是可以嵌套定义的。即在一个命名空间当中再定义一个命名空间，这种做法是被允许的。

比如：

namespace jxwd1
{
    namespace jxwd2
    {
        //...
    }
}

那么，有了命名空间，如何使用它呢？

3-2 命名空间的使用方式

准确来说，是有三种方式。

第一种方式：

直接展开。

就像我们之前写的using namespace std;一样。

直接写using namespace +命名空间名，这样的话就能将整个命名空间里面的内容全部展开使用了。也就是说，用这样的方法，在该文件中命名空间里的内容都可以直接拿来用。

第二种方式：

加命名空间名称及作用域限定符
比如：

printf("%d",jxwd::a);

就是说，直接命名空间名::变量名就可以了。

第三种：

使用using将命名空间中成员引入
举个例子：

using jxwd::b
printf("%d",jxwd::a);
printf("%d",b);

也就是说，我在前面加了一个using...，后面就可以直接用了。

四、C++ 输入输出

1.使用cout标准输出(控制台)和cin标准输入(键盘)时，必须包含< iostream >头文件以及std标准命名空间。
注意：早期标准库将所有功能在全局域中实现，声明在.h后缀的头文件中，使用时只需包含对应头文件即可，后来将其实现在std命名空间下，为了和C头文件区分，也为了正确使用命名空间，规定C++头文件不带.h；旧编译器(vc 6.0)中还支持<iostream.h>格式，后续编译器已不支持，因此推荐使用<iostream>+std的方式。
2. 使用C++输入输出更方便，不需增加数据格式控制，比如：整形--%d，字符--%c

这是我们用C++来写出的hello world

注意后面的是endl，相当于\n换行的意思。

而<<类似流，就是输出流的意思。

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

输入我们用cin，也是直接输入就可以。

比如，我们要实现一个两个数的加法

#include<iostream>
using namespace std;
int main()
{
	int a, b;
	cin >> a >> b;
	cout << a + b << endl;
	return 0;
}

是不是跟C相比，简单的不止一点点，什么%都不用写了。

五、缺省参数

各位知道什么叫做备胎么？

C++中函数也有备胎的概念。它就是缺省参数。

5-1 缺省参数概念

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

举个例子：

（虽然没有问题，但是我不知道其为什么会泛红）

从这个例子当中，我们可以看出，当 f函数内缺少实参的时候，其会调用其“备胎”，即会给出a的缺省值。

5-2 全缺省与半缺省

5-2-1 全缺省

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

像这样的，每一个参数都有一个“备胎”，即每一个参数都有一个缺省值，那么该函数就叫全缺省。

5-2-2 半缺省

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

像这样的，就叫半缺省

就是说，有部分元素有缺省值，而有部分元素没有缺省值，像这样的函数就是半缺省的。

5-2-3 半缺省时需要注意：

1. 半缺省参数必须从右往左依次来给出，不能间隔着给

2. 缺省参数不能在函数声明和定义中同时出现(尽量不要给。因为如果给出两个不一样的值，就会发生错误)

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

4. C语言不支持（编译器不支持）

六、函数重载

什么叫重载？

我们在日常生活中，一个词可以有多重含义，人们可以通过上下文来判断该词真实的含义，即该词被重载了。

简而言之，就是一个样子（名字），多种意思。

官方的意思：

C++ 允许多个函数拥有相同的名字，只要它们的参数列表不同就可以，这就是函数的重载（Function Overloading）

参数列表是什么意思？具体来说，就是参数类型（包含顺序）、参数名

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

int Add(int left, int right)
{
    return left+right;
}
int Add(double left, double right)
{
    return left+right;
}
long Add(long left, long right)
{
    return left+right;
}
int main()
{
    Add(10, 20);
    Add(10.0, 20.0);
    Add(10L, 20L);
    return 0;
}

如上面的代码，给出三个函数，它们的名字是相同的，但是其参数的类型是不同的。

所以，上面的三个函数就构成函数重载。

函数在调用时会如何调用呢？

答案是其会自动根据变量的类型，进行调用。

比如Add(10，20)，那么由于10和20是两个整型，则其会调用int Add(int left, int right)函数

其余的同理。

至于为什么C++支持这样的重载调用，而C不可以呢？

主要是因为C++和C对于函数调用的机制不同。这涉及到文件编译的内容了。

由于这部分在Linux系统下演示较为明显，但是笔者服务器到期了，笔者没钱.....所以就不演示了。

我们在这里就只是介绍一下：

在Linux环境中，C++对于函数调用的机制是函数名+函数名字符数+参数类型的首字母。

而C就仅仅是函数名

（在C和C++中的演示。图是我piao来的，，，哈哈哈哈）

通过这里就理解了C语言没办法支持重载，因为同名函数没办法区分。而C++是通过函数修饰规则来区分，只要参数不同，修饰出来的名字就不一样，就支持了重载。

另外我们也理解了，为什么函数重载要求参数不同！而跟返回值没关系

extern “C”
有时候在C++工程中可能需要将某些函数按照C的风格来编译，在函数前加extern "C"，意思是告诉编译器，将该函数按照C语言规则来编译。

七、引用

引用，是C++区别于C的一个重点和难点。

7-1 引用概念：

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

就是说，引用就是定义别名。

类型& 引用变量名(对象名) = 引用实体
比如：

int a = 10;
int& b = a; //a就是引用实体，b是引用对象名

那么这个时候，b就是a的别名，a和b指向同一块空间。

注意：引用类型必须和引用实体是同种类型的。

7-2 引用使用注意：

1. 引用在定义时必须初始化

2. 一个变量可以有多个引用

3. 引用一旦引用一个实体，再不能引用其他实体

7-3 常引用（const闪亮登场）

在C++中，const将会是一个重要人物闪亮登上编程舞台。

在这里，将会是第一次亮相。

常引用是对常量的引用。

const int a = 10;
int& b = a;

这是一个有问题的代码。

理由是什么呢?

a是const int类型，而b是int 类型。

b去引用a，从a到b，类型是从const int 到int ，它的权限增大了。这是不被允许的。

因为权限只能缩小，不能增大。一个非const的对象，可以在定义时定义成const类型，但是反过来就不行。很好理解。但是不知道在日后是否能够快速理解。。哈哈。

7-4 使用场景：

7-4-1 做引用

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

类似于我们在C中所说的用指针来实现的swap函数。

7-4-2 做返回值

int& Count()
{
    static int n = 0；
    n++;
    // ...
    return n;
}

细心的读者留意到，我们这里的n用的是static。

为什么呢？

如果我们写这么一段代码，试问结果会输出什么呢？

#include<iostream>
using namespace std;
int& Add(int a, int b)
{
	int c = a + b;
	return c;
}
int main()
{
	int& ret = Add(1, 2);
	cout << "Add(1, 2) is :" << ret << endl;
	return 0;
}

似乎并没有什么问题（如下图）

但是，我们会发现编译器报了一个警告。

我把屏蔽的内容解除来看看

这是怎么回事？

一句话。这和函数的返回值是一个临时变量的指针基本相似。

我们在C语言之前说过这是一个野指针。

笔者把链接附在这里：0基础C语言自学教程——第八节函数指针数组的各种关系_jxwd的博客-CSDN博客

可以自行查看。

我们来说说这里是怎么回事。这里是引用，毕竟不是指针。

0基础C语言自学教程——第九节从底层汇编的角度简单理解函数栈帧的创建和销毁_jxwd的博客-CSDN博客就是说，如果函数返回时，出了函数作用域，如果返回对象还未还给系统，则可以使用引用返回，如果已经还给系统了，则必须使用传值返回。我们在 0基础C语言自学教程——第九节从底层汇编的角度简单理解函数栈帧的创建和销毁 中详细介绍了。

7-5 传值、传引用效率比较

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

我们来简单比较一下传值和传引用返回的效率：

#include<iostream>
using namespace std;
#include <time.h>
struct A { int a[10000]; };
A a;
// 值返回
A TestFunc1() { return a; }
// 引用返回
A& TestFunc2() { return a; }
void TestReturnByRefOrValue()
{
	// 以值作为函数的返回值类型
	size_t begin1 = clock();
	for (size_t i = 0; i < 100000; ++i)
		TestFunc1();
	size_t end1 = clock();
	// 以引用作为函数的返回值类型
	size_t begin2 = clock();
	for (size_t i = 0; i < 100000; ++i)
		TestFunc2();
	size_t end2 = clock();
	// 计算两个函数运算完成之后的时间
	cout << "TestFunc1 time:" << end1 - begin1 << endl;
	cout << "TestFunc2 time:" << end2 - begin2 << endl;
}
int main()
{
	TestReturnByRefOrValue();
	return 0;
}

如图所示，可以看出，

传值返回和传引用返回的效率相差是非常大的。

7-6 引用和指针的比较

在语法概念上引用就是一个别名，没有独立空间，和其引用实体共用同一块空间。
在底层实现上实际是有空间的，因为引用是按照指针方式来实现的。

我们可以来对比一下指针和引用的汇编代码：

可以看到，二者一模一样，每有一丝丝的区别。

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

八、内联函数

内联函数概念

以inline修饰的函数叫做内联函数，编译时C++编译器会在调用内联函数的地方展开，没有函数压栈的开销，内联函数提升程序运行的效率

特性

1. inline是一种以空间换时间的做法，省去调用函数额开销。所以代码很长或者有循环/递归的函数不适宜使用作为内联函数。

2. inline对于编译器而言只是一个建议，编译器会自动优化，如果定义为inline的函数体内有循环/递归等等，编译器优化时会忽略掉内联。

3. inline不建议声明和定义分离，分离会导致链接错误。因为inline被展开，就没有函数地址了，链接就会找不到。

九、auto关键字(C++11)

在早期C/C++中auto的含义是：使用auto修饰的变量，是具有自动存储器的局部变量。可是没有多少人去使用它。因为对于局部变量而言似乎加不加它都是自动存储的。

C++11中，标准委员会赋予了auto全新的含义即：auto不再是一个存储类型指示符，而是作为一个新的类型指示符来指示编译器，auto声明的变量必须由编译器在编译时期推导而得

需要注意：

使用auto定义变量时必须对其进行初始化，在编译阶段编译器需要根据初始化表达式来推导auto的实际类型。

因此auto并非是一种“类型”的声明，而是一个类型声明时的“占位符”，编译器在编译期会将auto替换为变量实际的类型。

9-1 auto使用注意事项：

9-1-1 auto与指针和引用结合起来使用

用auto声明指针类型时，用auto和auto*没有任何区别，但用auto声明引用类型时则必须加&

就像这样：

#include<iostream>
using namespace std;
int main()
{
	int a = 10;
	auto& b = a;
	auto p = &a;  //也可以写作auto*
	return 0;
}

9-1-2 在同一行定义多个变量

当在同一行声明多个变量时，这些变量必须是相同的类型，否则编译器将会报错，因为编译器实际只对第一个类型进行推导，然后用推导出来的类型定义其他变量。

比如：

void f()
{
    
    auto a = 1,b = 2.0;  //这样是不允许的
}

9-1-3 auto不可以作为函数的参数

void f(auto a)//不允许
{}

9-1-4 auto不可直接用来声明数组

void f()
{
    auto a[] = {...};//不允许
}

为了避免与C++98中的auto发生混淆，C++11只保留了auto作为类型指示符的用法。
auto在实际中最常见的优势用法就是跟以后会讲到的C++11提供的新式for循环，还有lambda表达式等进行配合使用。

十、基于范围的for循环(C++11) （范围for）

C++98中，如果我们想要遍历一个数组，必须这样：

#include<iostream>
using namespace std;
int main()
{
	int a[5] = { 0,1,2,3,4 };
	for (int i = 0; i < sizeof(a) / sizeof(a[0]); i++)
	{
		cout << a[i] << " ";
	}
	return 0;
}

而在C++11中，我们可以这样写：

#include<iostream>
using namespace std;
int main()
{
	int a[5] = { 0,1,2,3,4 };
	for (auto e : a)
	{
		cout << e << " ";
	}
	return 0;
}

这就是大名鼎鼎的范围for：

for循环后的括号由冒号“ ：”分为两部分：第一部分是范围内用于迭代的变量，第二部分则表示被迭代的范围。它表示将第二部分的每一个元素都拿出来，然后赋值给第一部分所写的那一个临时变量.

范围for的使用条件

1.for循环迭代的范围必须是确定的对于数组而言，就是数组中第一个元素和最后一个元素的范围；对于类而言，应该提供begin和end的方法，begin和end就是for循环迭代的范围

像这个代码就是有问题的：

void TestFor(int array[])
{
    for(auto& e : array)
    cout<< e <<endl;
}

2. 迭代的对象要实现++和==的操作。（这个日后会讲）

十一、指针空值nullptr(C++11)

C++98中的空指针：

我们基本都是用NULL。

就像：

void f()
{
    int* p = NULL;
    //...
    
}

可是，实际上，编译器讲NULL往往定义成(void*)0

它实际上就是一个宏。

甚至在传统的编译器中，

直接就是

#define NULL 0

可以看到，NULL可能被定义为字面常量0，或者被定义为无类型指针(void*)的常量。不论采取何种定义，在使用空值的指针时，都不可避免的会遇到一些麻烦.

举个例子：

void f(int)
{
cout<<"f(int)"<<endl;
}
void f(int*)
{
cout<<"f(int*)"<<endl;
}
int main()
{
    f(0);
    f(NULL);    //该函数本意是想调用参数类型为int* 的函数，可以却调用了最上面的函数
    f((int*)NULL);
    return 0;
}

如上图所示。

所以。为了避免这样一种尴尬，在C++11中引入了nullptr的概念。

用它来表示指针的空值。

注意事项：

1. 在使用nullptr表示指针空值时，不需要包含头文件，因为nullptr是C++11作为新关键字引入的。
2. 在C++11中，sizeof(nullptr) 与 sizeof((void*)0)所占的字节数相同。
3. 为了提高代码的健壮性，在后续表示指针空值时建议最好使用nullptr。

好啦，本节内容到此结束啦~~~

欢迎关注关注加关注我呀

jxwd

关注

52
点赞
踩
15

收藏

觉得还不错? 一键收藏
打赏
25
评论
初阶C++——C++第一节——C++基础语法

这下，我前面什么都不想写了，上来就是正文，上来就肝。没有广告了！要说明一句，笔者在C中啰嗦过的语法在这里是不会再重复了的（什么分支循环什么的），相信如果我要是重复啰嗦的话，我不烦你们都烦了。一、什么是C++二、C++的发展史三、C++命名空间——关键字namespace3-1 命名空间的定义方法3-2 命名空间的使用方式四、C++ 输入输出五、缺省参数5-1 缺省参数概念5-2 全缺省与半缺省5-2-1 全缺省5-2-2 半缺省六、函数重载七、引用7-1 引用概念：7-2 引用使用注意：7-3 常
复制链接

扫一扫