C++练级之路（1）——C++入门

于 2024-04-24 23:47:15 发布
阅读量969 收藏 23
点赞数 29
分类专栏： C++学习 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/2301_80492355/article/details/137997861
版权

个人内容简介：

相关专栏

C++传送门

练题传送门

🍃个人主页：诉清风2023

☀️努力的意义从来不是成功，而是不留遗憾◕‿-｡

目录

​编辑

个人内容简介：

☀️努力的意义从来不是成功，而是不留遗憾◕‿-｡

前言

1、C++关键字

​编辑

2、命名空间

 2.1 命名空间定义

2.2 命名空间使用

3、C++的输入&输出

4、缺省参数

4.1 缺省参数的概念 

4.2 缺省参数的分类

5、函数重载

5.1 函数重载的概念 

5.2 函数重载的类型

5.3 C++支持函数重载的原理——名字修饰（name Mangling） 

6、引用

6.1 引用概念

6.2 引用特性

6.3 常引用 

6.4 使用场景

6.5 传值、传引用效率比较

6.6 引用和指针的区别 

7、内联函数

7.1 概念

7.2 特性

8、auto关键字（C++ 11）

8.1 概念

8.2 auto的使用细则

​编辑

8.3 auto不能推导的场景

9、基于范围的for循环（C++ 11）

9.1 范围for的语法

9.2 范围for的使用范围

10、指针空值nullptr（C++ 11）

10.1 C++ 98中的NULL

10.2 引入nullptr

结语

​编辑

前言

答疑：

C++是建立在C语言之上，改进了C中的一些缺陷，容纳进去了面向对象编程思想，并增加了许多有用的库，以及编程范式等。

本节目标：

1.理解C++开头写的两段代码究竟是什么意思

#include<iostream>
//该头文件有何意义？

using namespace std;
//这段代码是用来干什么的？

 2.理解C++在C基础之上增加了什么（函数重载，引用，auto关键字等等）

3.可以理解并熟练使用C++所增加的功能

1、C++关键字

C++共计63个关键字，C语言有32个关键字

2、命名空间

（即C语言中存在缺陷，为解决这种缺陷，出现了namespace关键字）

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

 简单来讲就是为了防止在同一作用域内的变量名冲突

#include<stdio.h>
#include<stdlib.h>
//C语言中使用该库函数后会使rand定义变量与库内函数冲突
//C++为解决这种问题，提出了namespace

int rand = 0;

int main()
{
	printf("%d\n", rand);
	return 0;
}

// 编译后后报错：error C2365: “rand”: 重定义；以前的定义是“函数”

 2.1 命名空间定义

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

  • 正常的命名空间定义
// 1. 正常的命名空间定义
namespace sqf  //
{
	// 命名空间中可以定义变量/函数/类型
	int rand = 10;       //变量

	int Add(int a, int b)//函数
	{
		return a + b;
	}

	typedef struct Student //结构体
	{
		int age;
		char name;
	}Stu;
}
  •  命名空间可以嵌套
//2. 命名空间可以嵌套
// test.cpp (在该文件中)
namespace sqf1
{
	int a;
	int b;
	int Add(int left, int right)
	{
		return left + right;
	}
	namespace sqf2
	{
		int c;
		int d;
		int Sub(int left, int right)
		{
			return left - right;
		}
	}
}
  • 同一个工程中允许存在多个相同名称的命名空间，最后编译器会合成为同一个命名空间
//3. 同一个工程中允许存在多个相同名称的命名空间,编译器最后会合成同一个命名空间中。
// ps：一个工程中的test.h和上面test.cpp中两个sqf1会被合并成一个
// test.h
namespace sqf1
{
	int Mul(int a, int b)
	{
		return a * b;
	}
}

注意：

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

2.2 命名空间使用

那么对于命名空间内的成员应该如何调用呢？

namespace sqf  //
{
	// 命名空间中可以定义变量/函数/类型
	int rand = 10;       //变量

	int Add(int a, int b)//函数
	{
		return a + b;
	}

	typedef struct Student //结构体
	{
		int age;
		char name;
	}Stu;
}

int main()
{
	// 编译报错：error C2065: “a”: 未声明的标识符
	// 如果一般调用会报错
	printf("%d\n", rand);

	return 0;
}

命名空间的使用有三种方式：

  • 加命名空间名称及作用域限定符
int main()
{
    printf("%d\n", sqf::rand);
    return 0;    
}
  • 使用using将命名空间中某个成员引入
using sqf::rand;
int main()
{
	printf("%d\n", rand);
	return 0;
}
  • 使用using namespace 命名空间名称引入
using namespace sqf;
int main()
{
	printf("%d\n", rand);
	Add(10, 20);
	return 0;
}

 总结：

通过该段内容应该可以理解了using namespace std;这段代码的含义了。即展开了C++自带的std命名空间内的内容，内容包含了我们目前可以使用的输入输出流[cin\cout]（实际上不仅仅如此，在此后的学习中会理解更多）

3、C++的输入&输出

#include <iostream>
using namespace std;
// std是C++标准库的命名空间名，C++将标准库的定义实现都放到这个命名空间中

int main()
{
   int a;
   double b;
   char c;
     
   // 可以自动识别变量的类型
   cin>>a;
   cin>>b>>c;
     
   cout<<a<<endl;
   cout<<b<<" "<<c<<endl;
   return 0;
}

说明：

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

2. cout和cin是全局的流对象，endl是特殊的C++符号，表示换行输出，他们都包含在包含< iostream >头文件中。

3. <<是流插入运算符，>>是流提取运算符。

4. 使用C++输入输出更方便，不需要像printf/scanf输入输出时那样，需要手动控制格式，C++的输入输出可以自动识别变量类型。

5. 实际上cout和cin分别是ostream和istream类型的对象，>>和也涉及运算符重载等知识， 这部分内容后续会学到。

注意：

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

 std命名空间的使用惯例：

std是C++标准库的命名空间，如何展开std使用更合理呢？

1. 在日常练习中，建议直接using namespace std即可，这样就很方便。

2. using namespace std展开，标准库就全部暴露出来了，如果我们定义跟库重名的类型/对 象/函数，就存在冲突问题。该问题在日常练习中很少出现，但是项目开发中代码较多、规模 大，就很容易出现。所以建议在项目开发中使用，像std::cout这样使用时指定命名空间 + using std::cout展开常用的库对象/类型等方式。

4、缺省参数

4.1 缺省参数的概念 

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

简单来讲就是可以在函数定义时为函数中的形参初始化

#include<iostream>
using namespace std;

void Func(int a = 0)//在C++中可以为函数中的参数定义初始值，C中是不可以的
{
	cout << a << endl;
}
int main()
{
	Func();     // 没有传参时，使用参数的默认值
	Func(20);   // 传参时，使用指定的实参

	return 0;
}

4.2 缺省参数的分类

  • 全缺省参数
void Func(int a = 1, int b = 2, int c = 3)
{
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	cout << "c = " << c << endl;
}
  • 半缺省参数
 void Func(int a, int b = 2, int c = 3)
 {
     //a 并没有给定初始值
     cout<<"a = "<<a<<endl;
     cout<<"b = "<<b<<endl;
     cout<<"c = "<<c<<endl;
 }

注意：

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

2. 缺省参数不能在函数声明和定义中同时出现

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

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

5、函数重载

5.1 函数重载的概念 

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

简单来讲就是可以创建相同函数名的函数

5.2 函数重载的类型

  • 参数类型不同
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;
}
  • 参数个数不同
void fun()
{
	cout << "Hello World!" << endl;
}
void fun(int a)
{
	cout << a << endl;
}
  • 参数顺序不同 
void fun(char a, int b)
{
	cout << a << " " << b << endl;
}
void fun(int b, char a)
{
	cout << a << " " << b << endl;
}

5.3 C++支持函数重载的原理——名字修饰（name Mangling） 

注意：

在这篇文章中我暂时无法讲清楚这个概念，可以等我之后文章，会专门写一篇关于这个原理的讲解，需要牵扯到程序编译过程，如果需要可以去查询其他博主的文章

6、引用

6.1 引用概念

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

 简单来讲是为了代替指针的使用

 引用的使用：类型& 引用变量名(对象名) = 引用实体；

#include<iostream>
using namespace std;

int main()
{
	//引用

	int a = 0;
	int& b = a;//b是a的别名
	int& c = a;//可以给一个变量取多个别名
	int& d = b;//可以给别名取别名

	++d;
	cout << a << endl;  //a = 1

	cout << &a << endl;  //地址相同
	cout << &b << endl;
	cout << &c << endl;
	cout << &d << endl;
	return 0;
}

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

6.2 引用特性

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

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

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

#include<iostream>
using namespace std;

int main()
{
	int a = 0;
	// int& ar;  此处会报错 必须初始化
	int& ra = a;
	int b = 10;
	ra = b;  //此处是将b的变量名给到了ra,而不是将ra变成b的别名
	cout << &a << endl << &ra << endl << &b << endl;
}

6.3 常引用 

int main()
{
	const int a = 10;
	//int& ra = a;     // 该语句编译时会出错，a为常量
	const int& ra = a; // 这样是可以的

	// int& b = 10;   // 该语句编译时会出错，b为常量
	const int& b = 10;

	double d = 12.34;
	//int& rd = d; // 该语句编译时会出错，类型不同
	const int& rd = d;
}

注意：这里引入一个有意思代码，上面讲到 int& ra 不能够用来引用 const int a 的数据 ，那么下面这个代码能否正常使用呢？

#include<iostream>
using namespace std;

int main()
{
	const int a = 10;
	const int& ra = a;
	int b = a;  //这个代码有没有问题？
	
	//显然编译器没有报错，证明正确
	//因为此处并不是权限的放大，而是将 a 的内容拷贝给 b
	//                            b 的修改不会影响 a

	int x = 10;
	const int* p1 = &x;
	//p1++;          //p1的值可以改变，因为const修饰的是*p1即x的值
	//int* p2 = p1;  //这里会报错，因为如果将p1的值赋给p2,可以通过解引用p2来修改x的值
	const int* p2 = p1;
    //总体来说，权限只能缩小或者等同，不能放大
	return 0;
}

6.4 使用场景

  • 做参数（交换两个数据）
#include<iostream>
using namespace std;

void Swap1(int* a, int* b)
{
	//C语言中交换两个变量的数据用这种方法
	int temp = *a;
	*a = *b;
	*b = temp;
}

void Swap2(int& a, int& b)
{
	//C++中交换两个变量的数据
	int temp = a;
	a = b;
	b = temp;
}

int main()
{
	
	int a = 10;
	int b = 20;
	cout << "交换前" << a << ":" << b << endl;
	Swap1(&a, &b);//c指针法
	cout << "交换后" << a << ":" << b << endl;

	int c = 30;
	int d = 40;
	cout << "交换前" << c << ":" << d << endl;
	Swap2(c, d);//C++引用法
	cout << "交换后"<< c << ":" << d << endl;
	return 0;
}
  • 做返回值
int& Count()
{
	static int n = 0;
	n++;
	// ...
	return n;
}

6.5 传值、传引用效率比较

传引用效率远远大于传值（可以用下方代码进行比较）

#include<iostream>
#include <time.h>
using namespace std;
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 < 10000; ++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;
}

#include<iostream>
#include <time.h>
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;
}

6.6 引用和指针的区别 

引用：

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

引用和指针的不同点:

1. 引用概念上定义一个变量的别名，指针存储一个变量地址。

2. 引用在定义时必须初始化，指针没有要求

3. 引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型实体

4. 没有NULL引用，但有NULL指针

5. 在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32 位平台下占4个字节)

6. 引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小

7. 有多级指针，但是没有多级引用

8. 访问实体方式不同，指针需要显式解引用，引用编译器自己处理

9. 引用比指针使用起来相对更安全

7、内联函数

7.1 概念

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

简单理解就是内联函数是为了降低多次重复使用的小函数所消耗的栈帧的开销

 接下来我们来看一下在使用inline函数前后对于函数栈帧调用的改变

查看方法：

        1. 在release模式下，查看编译器生成的汇编代码中是否存在call Add

        2. 在debug模式下，需要对编译器进行设置，否则不会展开(因为debug模式下，编译器默认不会对代码进行优化，以下给出vs2013的设置方式)

 dubug模式下的设置方法如下：

  • inline调用前 

  • inline调用后

7.2 特性

1.inline是一种以空间换时间的做法，如果编译器将函数当成内联函数处理，在编译阶段，会 用函数体替换函数调用。

2.inline对于编译器而言只是一个建议，不同编译器关于inline实现机制可能不同。一般建议：将函数规模较小、不是递归、且频繁调用的函数用inline修饰，否则编译器会忽略inline特性。

3. inline不建议声明和定义分离（即在头文件中声明，源文件中调用），分离会导致链接错误。因为inline被展开，就没有函数地址 了，链接就会找不到。

8、auto关键字（C++ 11）

8.1 概念

auto是用来自动推导表达式或变量的实际类型的。

#include<iostream>
using namespace std;

int main()
{
    int a = 0;
    auto b = a;//此时b为int 类型
    cout << typeid(a).name() << endl;//typeid().name()可以自动识别变量的类型
    cout << typeid(b).name() << endl;
    return 0;
}

注意：

使用auto定义变量时必须对其进行初始化，在编译阶段编译器需要根据初始化表达式来推导auto的实际类型。因此auto并非是一种“类型”的声明，而是一个类型声明时的“占位符”，编译器在编译期会将auto替换为变量实际的类型。

8.2 auto的使用细则

  • auto与指针和引用结合起来使用

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

  • 在一行中定义多个变量

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

8.3 auto不能推导的场景

  1.  auto不能作为函数的参数
  2. auto不能直接用来声明数组
  3. 为了避免与C++98中的auto发生混淆，C++11只保留了auto作为类型指示符的用法
  4. auto在实际中最常见的优势用法就是跟C++11提供的新式for循环，还有 lambda表达式等进行配合使用。

9、基于范围的for循环（C++ 11）

9.1 范围for的语法

在C++ 98中要遍历数组我们会用下面这种方法

#include<iostream>
using namespace std;

int main()
{
    int arr[] = { 1,2,3,4,5 };
    for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
    {
        arr[i] *= 2;  //给每个数据扩大两倍
    }
    for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
    {
        cout << arr[i] << " ";  //遍历输出
    }
    cout << endl;
    return 0;
}

但是在C++ 11中我们可以换个方式来使用

#include<iostream>
using namespace std;

int main()
{
    int arr[] = { 1,2,3,4,5 };
    //  auto这里的作用：
    //  自动获取数组arr中的数据赋值给e
    //  自动++，自动判断循环是否结束
    for (auto e : arr)
    {
        cout << e << " ";
    }
    cout << endl;  //这里遍历打印完数组内的数据了

    //  这里的e相当于是对arr中数据的拷贝，所以不能对其数组内的数据进行运算
    for (auto e : arr)  //如果想要让数据发生改变，则写成 (auto& e : arr) 对数据引用
    {
        e -= 1;
    }
    for (auto e : arr)
    {
        cout << e << " ";
    }
    cout << endl; // 遍历打印后发现，数据内容并没有改变
    return 0;
}

9.2 范围for的使用范围

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

2.迭代的对象要实现 ++ 和 == 的操作

10、指针空值nullptr（C++ 11）

10.1 C++ 98中的NULL

//  在传统的C头文件(stddef.h)中对NULL的定义
#ifndef NULL
#ifdef __cplusplus
#define NULL   0
#else
#define NULL   ((void *)0)
#endif
#endif

 NULL实际上是一个宏，但是在此处NULL可能被定义为字面常量0，或者被定义为无类型指针(void*)的常量。（这就不可避免的在使用空值指针时，会出现错误）如下所示：

 

10.2 引入nullptr

注意：

1. nullptr表示指针空值，不需要包含头文件，因为nullptr是C++11作为新关键字引入的。

2. 在C++11中，sizeof(nullptr) 与 sizeof((void*)0)所占的字节数相同。

3. 为了提高代码的健壮性，在后续表示指针空值时建议最好使用nullptr。

结语

🪁️至此，我们初次了解C++就到这里啦，愿大家都有所收获

评论 7
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值