1. 入门

已于 2022-05-15 20:00:09 修改
阅读量244 收藏
点赞数
分类专栏： cpp 文章标签： c++ c语言 开发语言
于 2022-05-15 15:43:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62513305/article/details/124782918
版权

文章目录

cpp关键字(cpp98)

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

c++关键字：

asmdo ifreturn trycontinue
autodoubleinlineshorttypedeffor
booldynamic_castintsignedtypeidpublic
breakelselongsizeoftypenamethrow
caseenummutablestaticunionwchar_t
catchexplicitnamespacestatic_castunsigneddefault
charexportnewstructusingfriend
classexternoperatorswitchvirtualregister
constfalseprivatetemplatevoidtrue
const_castfloatprotectedthisvolatilewhile
deletegotoreinterpret_cast

命名空间

在c/c++中，变量，函数和类都是大量存在的，这些变量、函数和类的名称将存在于全局作用域中，可能会导致命名冲突。

使用命名空间可以解决这个冲突。

使用命名空间的目的是对标识符的名称进行本地化，以避免命名冲突或者名字污染。用namespace关键字。

定义

// 下面的代码是错误的 
// pow 在math.h 中被定义为函数 
// 当在预处理的时候 会将头文件展开 两个pow产生的冲突 
// 但可以在局部定义这个名字 局部和全局相同时 局部会覆盖全局
// 可以将变量名放在不同的命名空间来解决这个问题

#include <iostream>
#include <math.h>

int pow = 30;

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

// 命名空间的定义 
// 普通的命名空间 
// namespace 加 命名空间的名称 方括号内跟着属于这个命名空间的变量
// 可以使用域作用限定符 和 属于这个域的变量来使用和访问这个变量 域名::变量名
// 命名空间的作用范围是全局的 

#include <iostream>
#include <math.h>

namespace ToodlesFate 
{
	int pow = 30;
}

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

// 命名空间的嵌套
#include <iostream>
#include <math.h>

namespace ToodlesFate1
{
	int pow = 30;
	int sqrt = 20;
	namespace ToodlesFate2
	{
		int Add(int a, int b) 
		{
			return a + b;
		}
		namespace ToodlesFate3
		{
			int sub(int d, int f) 
			{
				return d - f;
			}

		}
	}
}

int main()
{
	// 命名空间中变量的使用
	printf("%d\n", ToodlesFate1::pow);
	printf("%d\n", ToodlesFate1::ToodlesFate2::Add(2, 3));
	printf("%d\n", ToodlesFate1::ToodlesFate2::ToodlesFate3::sub(5, 1));
	return 0;
}

// 同一个工程中允许有多个相同的命名空间 编译器最后会合成一个同一个命名空间
// 对于最外层

// error
// 说明会将相同命名空间和在一起
namespace ToodlesFate1
{
	int a = 10;
	int b = 20;
	namespace func1
	{
		int add(int x, int y)
		{
			return x + y;
		}
	}
}

namespace ToodlesFate1
{
	int a = 10;
	int b = 20;
	namespace func2
	{
		int mul(int x, int y)
		{
			return x * y;
		}
	}
}
// 下面是一个正确的
#include <iostream>

namespace ToodlesFate1
{
	int a = 10;
	int b = 20;
	namespace func1
	{
		int add(int x, int y)
		{
			return x + y;
		}
	}
}

namespace ToodlesFate1
{
	int c = 10;
	int d = 20;
	namespace func2
	{
		int mul(int x, int y)
		{
			return x * y;
		}
	}
}


int main()
{
	printf("%d\n", ToodlesFate1::func1::add(2, 3));
	printf("%d\n", ToodlesFate1::func2::mul(2, 3));
	return 0;
}

使用

使用命名空间的内容，有三种方式

  1. 命名空间名称及域作用限定符
  2. 使用using 将命名空间中的成员导入
  3. 使用using namespace 将命名空间导入
// 命名空间名称及域作用限定符
#include <cstdio>

namespace ToodlesFate
{
	int a = 10;
	int b = 20;
	int Add(int x, int y)
	{
		return x + y;
	}

	namespace ToodlesFate1
	{
		int c = 30;
		int d = 40;
		int sub(int x, int y)
		{
			return x - y;
		}
	}
}

int main()
{
	printf("%d\n", ToodlesFate::a);
	printf("%d\n", ToodlesFate::b);
	printf("%d\n", ToodlesFate::Add(2, 3));
	printf("%d\n", ToodlesFate::ToodlesFate1::c);
	printf("%d\n", ToodlesFate::ToodlesFate1::d);
	printf("%d\n", ToodlesFate::ToodlesFate1::sub(5, 2));
	return 0;
}

// 使用using将命名空间中的成员导入
#include <cstdio>

namespace ToodlesFate
{
	int a = 10;
	int b = 20;
	int Add(int x, int y)
	{
		return x + y;
	}

	namespace ToodlesFate1
	{
		int c = 30;
		int d = 40;
		int sub(int x, int y)
		{
			return x - y;
		}
	}
}

// using ToodlesFate::a
// 将ToodlesFate的命名空间中的a变量从命名空间中放出来
using ToodlesFate::a;               // int a = 10;
using ToodlesFate::b;               // int b = 20;
using ToodlesFate::Add;             // int Add(int x, int y) {return x + y;}
using ToodlesFate::ToodlesFate1::c; // int c = 30;
using ToodlesFate::ToodlesFate1::d; // int d = 40;

int main()
{
	printf("%d\n", a);
	printf("%d\n", b);
	printf("%d\n", c);
	printf("%d\n", d);
	printf("%d\n", Add(2, 3));
	printf("%d\n", ToodlesFate::ToodlesFate1::sub(2, 3));
	return 0;
}

// 使用using namespace 将命名空间导入
// 使用 导入命名空间时 必须先导入 外部 再导入内部
#include <cstdio>

namespace ToodlesFate
{
	int a = 10;
	int b = 20;
	int Add(int x, int y)
	{
		return x + y;
	}

	namespace ToodlesFate1
	{
		int c = 30;
		int d = 40;
		int sub(int x, int y)
		{
			return x - y;
		}
	}
}

// 相当于将命名空间中的全部内容展开
using namespace ToodlesFate;
using namespace ToodlesFate1;

int main()
{
	printf("%d\n", a);
	printf("%d\n", b);
	printf("%d\n", c);
	printf("%d\n", d);
	printf("%d\n", Add(2, 3));
	printf("%d\n", sub(2, 3));
	return 0;
}

// erro
namespace ToodlesFate
{
	int a = 10;
	int b = 20;
	int Add(int x, int y)
	{
		return x + y;
	}

	namespace ToodlesFate1
	{
		int c = 30;
		int d = 40;
		int sub(int x, int y)
		{
			return x - y;
		}
	}
}

using namespace ToodlesFate1;
using namespace ToodlesFate;

// 也可以如下导入
#include <cstdio>

namespace ToodlesFate
{
	int a = 10;
	int b = 20;
	int Add(int x, int y)
	{
		return x + y;
	}

	namespace ToodlesFate1
	{
		int c = 30;
		int d = 40;
		int sub(int x, int y)
		{
			return x - y;
		}
	}
}

using namespace ToodlesFate::ToodlesFate1;
using namespace ToodlesFate;

C++的输入和输出

c++使用cin和cout来输入和输出。使用cin和cout时必须引用头文件iostream。

cin：流提取操作符

cout：流插入操作符

// 使用流插入操作符
// endl 是换行
#include <iostream>

using namespace std;

int main()
{
	char a = 'a';
	short b = 10;
	int c = 30;
	long d = 40;
	float e = 3.14f;
	double f = 23.455;
	string s = "hello world";
	cout << a << " " << b << " " << c << " " << d << " " << e << " " << f << " " << s << endl;
	return 0;
}

// 使用流提取操作符
// cin 读取字符串时 遇到空格停止
// 使用cin cout 好处 不需要控制输入和输出格式

#include <iostream>

using namespace std;

int main()
{
	char a ;
	short b;
	int c;
	long d;
	float e;
	double f;
	string s;
	cin >> a >> b >> c >> d >> e >> f >> s;
	cout << a << " " << b << " " << c << " " << d << " " << e << " " << f << " " << s << endl;
	return 0;
}

缺省参数

概念

缺省参数：在定义函数时，给参数一个默认值，如果没有传进来参数，默认使用这个参数。

缺省参数必须从右到左排列

// 如果函数的声明和定义在同一个文件中
// 可以给声明缺省 或者给定义缺省 或者两个都缺省 两个都缺省时缺省值必须相同
// 定义缺省
#include <iostream>

using namespace std;

void test(int a, int b);

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

int main()
{
	test(10);
	return 0;
}

// 声明缺省
#include <iostream>

using namespace std;

void test(int a, int b = 20);

void test(int a , int b)
{
	cout << a << " " << b << endl;
}

int main()
{
	test(10);
	return 0;
}

// 如果将声明和定义分开 
// 若要定义缺省参数 
// 只能在声明中缺省， 不能在定义中缺省 
// 因为在预处理时 会将#include 展开 
// 在编译过程会进行比对 如果不同的话会报错

// 正确的
// Test.h
#pragma once
#include <iostream>

using namespace std;

void Test(int a, int b = 10);

// Test.cpp
#include "Tets.h"

void Test(int a, int b)
{
	cout << a << " " << b << endl;
}

// main.cpp
#include "Tets.h"

int main()
{
	Test(1);
	return 0;
}

// 错误的
// Test.h
#pragma once
#include <iostream>

using namespace std;

void Test(int a, int b);

// Test.cpp
#include "Tets.h"

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

// main.cpp
#include "Tets.h"

int main()
{
	Test(1);
	return 0;
}

// 错误的
// Test.h
#pragma once
#include <iostream>

using namespace std;

void Test(int a, int b = 10);

// Test.cpp
#include "Tets.h"

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

// main.cpp
#include "Tets.h"

int main()
{
	Test(1);
	return 0;
}

分类

缺省参数类型有两种：

  1. 全缺省参数
  2. 半缺省参数
// 全缺省参数
// 没有给实参时，使用默认的参数
// 给了实参之后，从左向右匹配
#include <iostream>

using namespace std;

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

int main()
{
	fun();
	fun(1);
	fun(1, 2);
	fun(1, 2, 3);
	return 0;
}

// 半缺省参数
// 只能从右向左缺省
#include <iostream>

using namespace std;

// 正确的
void fun(int a, int b, int c = 30)
{
	cout << a << " " << b << " " << c << endl;
}

// 错误的
//void func(int a = 10, int b = 20, int c)
//{
//	cout << a << " " << b << " " << c << endl;
//}

int main()
{
	// 错误的调用
	//fun();
	//fun(1);
	fun(1, 2);
	fun(1, 2, 3);
	return 0;
}

函数重载

函数重载的概念

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

// 参数的类型不同
#include <iostream>

using namespace std;

int Add(int a, int b)
{
	cout << "Add(int a, int b)" << endl;
	return a + b;
}

double Add(double a, double b)
{
	cout << "Add(double a, double b)" << endl;
	return a + b;
}

int main()
{
	cout << Add(2, 3) << endl;
	cout << Add(2.0, 3.0) << endl;
	return 0;
}

// 参数的个数不同
#include <iostream>

using namespace std;

int add(int a, int b, int c)
{
	cout << "add(int a, int b, int c)" << endl;
	return a + b + c;
}

int add(int a, int b)
{
	cout << "add(int a, int b)" << endl;
	return a + b;
}

int main()
{
	cout << add(1, 2) << endl;
	cout << add(1, 2, 3) << endl;
	return 0;
}

// 参数的顺序不同
#include <iostream>

using namespace std;

double add(double a, int b)
{
	cout << "add(double a, int b)" << endl;
	return a + b;
}

double add(int a, double b)
{
	cout << "add(int a, double b)" << endl;
	return a + b;
}

int main()
{
	cout << add(2.1, 3) << endl;
	cout << add(3, 2.1) << endl;
	return 0;
}

函数重载的原理

cpp在编译完成后，对函数的名称进行了重新安排，新名字显示了函数的名字，长度，参数类型等

编译链接的过程：

  1. 预处理：头文件的展开、宏替换、条件编译、去掉注释 -> .i
  2. 编译：检查语法，生成汇编代码 -> .s
  3. 汇编：把汇编代码转换为二进制的机器码 -> .o
  4. 链接：找调用函数的地址，链接对应上，合并到一起 -> .out

cpp对函数的名词进行重新安排，在函数重载后在符号表中对应的字符串不同，所以支持。

c语言没有对函数的名词进行安排，在函数重载后符号表中对应的字符串相同，所以不支持

C/C++互相调用

调用时调用的是另一文件的静态库，需要进行环境配置, c和c++ 进行互相调用时，都是对c++做处理

C可以调用C/C++

C++可以调用C/C++

  • C调用C

      1. 先创建一个c工程，然后将其改为静态库(点击工程 -> 属性 -> 常规 -> 配置类型 -> 静态库(.lib))
      2. 然后编译生成静态库文件
      3. 在c工程中配置：
        1. (点击工程 -> 连接器 -> 常规 -> 添加库目录 -> 将编译生成的静态库添加进去(可以在这里找))
        2. (点击工程 -> 连接器 -> 输入 -> 将静态库名字加进去用分号与其他的分开)
      4. 包含头文件：头文件要写清楚路径，一直从当前到目标静态库的头文件

  • C调用C++（也是对cpp进行操作）

      1. 先创建一个cpp工程，然后将其改为静态库(点击工程 -> 属性 -> 常规 -> 配置类型 -> 静态库(.lib))

      2. 然后编译生成静态库文件

      3. 在c工程中配置：

        1. (点击工程 -> 连接器 -> 常规 -> 添加库目录 -> 将编译生成的静态库添加进去(可以在这里找))
        2. (点击工程 -> 连接器 -> 输入 -> 将静态库名字加进去用分号与其他的分开)

      4. 在cpp中进行的操作

        #ifdef __cplusplus
	#define EXTERN_C extern "C"
#else 
	#define EXTERN_C
#endif

EXTERN_C 函数的声明
// __cplusplus 在 cpp 中为真 c 中为假 可以告诉 cpp 编译按照 c 的方式来编译同时不会在c中报告错误

        #ifdef __cplusplus
extern "C"
	{
#endif 
    // pass 函数
#ifdef __cplusplus    
	}
#endif

      5. 包含头文件：头文件要写清楚路径，一直从当前到目标静态库的头文件

  • C++调用C

      1. 先创建一个c工程，然后将其改为静态库(点击工程 -> 属性 -> 常规 -> 配置类型 -> 静态库(.lib))
      2. 然后编译生成静态库文件
      3. 在cpp工程中配置：
        1. (点击工程 -> 连接器 -> 常规 -> 添加库目录 -> 将编译生成的静态库添加进去(可以在这里找))
        2. (点击工程 -> 连接器 -> 输入 -> 将静态库名字加进去用分号与其他的分开)
      4. 包含头文件：使用extern "C" {头文件}头文件要写清楚路径，一直从当前到目标静态库的头文件

  • C++调用C++

      1. 先创建一个cpp工程，然后将其改为静态库(点击工程 -> 属性 -> 常规 -> 配置类型 -> 静态库(.lib))
      2. 然后编译生成静态库文件
      3. 在cpp工程中配置：
        1. (点击工程 -> 连接器 -> 常规 -> 添加库目录 -> 将编译生成的静态库添加进去(可以在这里找))
        2. (点击工程 -> 连接器 -> 输入 -> 将静态库名字加进去用分号与其他的分开)
      4. 包含头文件：头文件要写清楚路径，一直从当前到目标静态库的头文件

引用

概念

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

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

// 引用的使用
#include <iostream>
using namespace std;

int main()
{
	int a = 10;
	int& ra = a;
	cout << a << " " << ra << endl;
	a++;
	cout << a << " " << ra << endl;
	ra++;
	cout << a << " " << ra << endl;

	return 0;
}

  // 使用引用交换两个变量的位置
  #include <iostream>
  
  using namespace std;
  
  void swap(int& a, int& b)
  {
  	int tmp = a;
  	a = b;
  	b = tmp;
  }
  
  int main()
  {
  	int a = 10, b = 20;
  	cout << "a = " << a << " b = " << b << endl;
  	swap(a, b);
  	cout << "a = " << a << " b = " << b << endl;
  	return 0;
  }
  
  // 不使用引用交换两个元素的位置
  #include <iostream>
  
  using namespace std;
  
  void swap(int* a, int* b)
  {
  	int tmp = *a;
  	*a = *b;
  	*b = tmp;
  }
  
  int main()
  {
  	int a = 10, b = 20;
  	cout << "a = " << a << " b = " << b << endl;
  	swap(&a, &b);
  	cout << "a = " << a << " b = " << b << endl;
  	return 0;
  }

特性

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

    // erro
#include <iostream>
          
using namespace std;
          
int main()
{
	int& a;
	return 0;
}

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

    #include <iostream>
#include <cstdio>
          
using namespace std;
          
int main()
{
	int p = 10;
	int& rp = p;
	int& rrp = p;
    // 打印出来的结果表明 p rp rrp 的值与地址相同 说明一个变量可以有多个引用
	cout << p << " " << rp << " " << rrp << " " << endl;
	printf("%p %p %p", &p, &rp, &rrp);
	return 0;
}

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

    #include <iostream>
          
using namespace std;
          
int main()
{
	int a = 10;
	int& b = a;
	int c = 20;
	b = c;          // 把c 的值赋值给b 不是把c引用给b
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	cout << "c = " << c << endl;
	return 0;
}

常引用

  1. 在引用时，权限只能放下，不能将权限扩大。例如：如果一个变量只允许读，不允许修改，则通过引用也只可以读，不能修改；如果一个允许读与写，则创建引用时，可以创建既能读取也能修改或者只能读取不能修改。

    #include <iostream>

using namespace std;

int main()
{
	// 进行对变量引用时 权限只能缩小 不能放大

	// 只有读取的权限
	const int x = 20;
	//int& y = x; 有读取 和 修改的权限 权限扩大了 是错误的
	// 只有读取的权限
	const int& y = x;

	// 有读取的和修改的权限
	int c = 30;
	// 有读取的和修改权限
	int& b = c;
	// 只有读取的权限
	const int& d = c;
	return 0;
}

  2. 临时变量具有常属性

    #include <iostream>
          
using namespace std;
          
int main()
{
	double a = 2.2;
	// 将浮点数a的整数部分截取出来 然后拷贝一份 把他赋值给f
	int f = a;
          
	// 引用：
	// 	把浮点数a的整数部分截取出来 然后然后把那个常数的引用赋值给e
	// 	它具有只读性 不能被修改 具有常性
	//int& e = a;
	const int& e = a;
	return 0;
}

引用的应用场所

  1. 做参数: 输出型参数能够减少拷贝 提高效率

    #include <iostream>
          
using namespace std;
          
void swap(int& a, int& b)
{
	int tmp = a;
	a = b;
	b = tmp;
}
          
int main()
{
	int a = 10;
	int b = 20;
	cout << "a = " << a;
	cout << " b = " << b << endl;
	swap(a, b);
	cout << "a = " << a;
	cout << " b = " << b << endl;
	return 0;
}

  2. 做返回值：函数返回后，出了函数的作用域，如果返回对象的空间未还给系统，则可以使用引用返回；如果返回的空间已经还给系统，那么，不能使用引用，需要使用传值返回

    // 空间未还给系统
// 可以使用引用返回
#include <iostream>
          
using namespace std;
          
int& count()
{
	static int n = 0;
	n++;
	return n;
          
}
          
int main()
{
          
	for (int i = 0; i < 10; i++) {
		cout << "第 " << count() << "调用" << endl;
	}
	return 0;
}

    // 空间已经还给系统
// 不可以使用引用返回
// 应该使用拷贝值返回
#include <iostream>
          
using namespace std;
          
int& add(int& a, int& b)
{
	int c = a + b;
	return c;
}
          
int main()
{
	int a = 2;
	int b = 3;
	int& ret = add(a, b);
	// 返回值的空间被还给系统 
	// 当调用完一次之后 再次访问后被随机值覆盖
	// 最好使用传值返回
	// 一个常数不能被修改  1 不能用int& 来接受
	cout << "add(2, 5)" << ret << endl;
	cout << "add(2, 5)" << ret << endl;
	cout << "add(2, 5)" << ret << endl;
	return 0;
}

传值和传引用的对比

值：将值作为参数和返回类型时，在传递参数和返回值的时候，函数不会直接传递实参或者变量本身，而是传递实参或者返回值的一份临时的拷贝。拷贝需要耗时，所以效率低下。

// 传值调用和传引用调用的耗时比较

#include <iostream>
#include <time.h>

using namespace std;

// 定义一个结构体
// 结构体中的变量是 10000 个整型值
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;

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

引用和指针的对比

  1. 引用是一个变量的别名，不占空间；指针存放变量的地址，占空间
  2. 引用在定义时必须初始化，指针没有要求
  3. 引用在初始化引用一个实体之后，就不能引用其他实体了，而指针可以在任何时候指向任何一个同类型的实体
  4. 没有NULL引用，但有NULL指针
  5. 在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数
  6. 引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小
  7. 有多级指针，但是没有多级引用
  8. 访问实体方式不同，指针需要显式解引用，引用编译器自己处理
  9. 引用比指针使用起来相对更安全
  10. 引用和指针在汇编代码的结果是相同的。
// 观察指针和引用的汇编代码是相同的 
// 在 return 的上一个句子上打一个断点
// 然后允许到这句后 点右击 转到反汇编
// 观察汇编代码
#include <iostream>

using namespace std;

int main()
{
	int a = 10;

	int& ra = a;
	ra = 20;

	int* pa = &a;
	*pa = 20;

	return 0;
}

内联函数

概念

用inline修饰的函数叫做内联函数。

在编译时，C++编译器会将在调用内联函数的地方展开，没有函数压栈的开销(类似宏)。

查看方式：

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

    // 打断点，调试，查看反汇编
#include <iostream>
     
using namespace std;
     
inline int add(int a, int b)
{
	return a + b;
}
     
int main()
{
	int res = add(1, 2);
	return 0;
}

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

    点击文件 -> 右键 -> 属性 -> c/c++ -> 常规 -> 改为程序设计库(/zi) -> 优化 - > 内联函数扩展改为 只使用于 __inline(/Ob1)

    // 先进行配置 
// 然后打断点 调试 转为汇编
     
#include <iostream>
     
using namespace std;
     
inline int add(int a, int b)
{
	return a + b;
}
     
int main()
{
	int res = add(1, 2);
	return 0;
}

特性

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

    // 会展开
#include <iostream>

using namespace std;

inline void test(int n)
{
	for (int i = 0; i < n; i++);
}

int main()
{
	test(100);
	return 0;
}

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

       // 定义的内连函数会自动忽略 长度太长
       
       #include <iostream>
       
       using namespace std;
       
       inline void test()
       {
       	int x = 1;
       	int y = 1;
       	int z = x + y;
       	z += x + y;
       	z += x + y;
       	z += x + y;
       	z += x + y;
       	z += x + y;
       	z += x + y;
       	z += x + y;
       	z += x + y;
       	z += x + y;
       	z += x + y;
       	z += x + y;
       	z += x + y;
       	z += x + y;
       	z += x + y;
       	z += x + y;
       }
       
       int main()
       {
       	test();
       	return 0;
       }

     // 定义的内联函数会被忽略 使用了递归
    #include <iostream>
    
    using namespace std;
    
    inline void test(int n)
    {
    	if (n >= 0) test(n - 1);
    }
    
    int main()
    {
    	test(100);
    	return 0;
    }

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

    // 内联函数不会创建符号表 所以如果分开写 会链接不到

// In.h
#include <iostream>
using namespace std;
inline void f(int i);

// In.cpp
#include "In.h"
void f(int i)
{
	cout << i << endl;
}

// test.cpp
#include "In.h"

int main()
{
	f(10);
	return 0;
}

宏：

// 宏和内联函数一样 都是在编译的时候进行代替
#include <iostream>

using namespace std;

#define ADD(x, y) ((x) + (y))

int main()
{
	cout << ADD(2, 3) << endl;
	return 0;
}

宏和内联函数的区别：

  1. 宏的优点：
    1. 增强代码的复用性
    2. 提高性能
  2. 宏的缺点：
    1. 提高性能
    2. 导致代码可读性差，可维护性差，容易误用
    3. 没有类型安全的检查
  3. 内联函数的优点：
    1. 解决宏函数晦涩难懂，容易写错的问题
    2. debug支持调试
    3. 不容写错，就是普通函数的写法

#auto、for、nullptr

auto

含义：auto声明的变量必须由编译器在编译时期推导而得

注：

  1. 使用auto定义变量时必须对其进行初始化，在编译阶段编译器需要根据初始化表达式来推导auto的实际类
    型
  2. auto并非是一种类型的声明，而是一个类型声明时的占位符，编译器在编译期会将auto替换为变量实际的类型
// 使用auto 推导变量的类型 并显示出来
#include <iostream>

using namespace std;

short test()
{
	return 3;
}

int main()
{
	int a = 10;
	auto b = 'a';
	auto c = "hello world";
	auto d = 3.1415936;
	auto f = test();
	auto g = { 1, 2, 3 };
	auto i = { 'h', 'e', 'l' };

	// typeid(a).name() 能够返回a的类型
	cout << typeid(a).name() << endl;
	cout << typeid(b).name() << endl;
	cout << typeid(c).name() << endl;
	cout << typeid(d).name() << endl;
	cout << typeid(f).name() << endl;
	cout << typeid(g).name() << endl;
	cout << typeid(i).name() << endl;

	return 0;
}

auto的使用细则：

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

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

    // 当定义指针时 可从下方得到 加不加* 都可以
// 当定义引用时 若不加时 auto 自动推导为那个值的临时拷贝 占用内存
#include <iostream>

using namespace std;

int main()
{
	int x = 10;
	auto a = &x;
	auto* b = &x;
	auto& c = x;
	auto e = x;
	cout << typeid(a).name() << endl;
	cout << typeid(b).name() << endl;
	cout << typeid(c).name() << endl;
	cout << typeid(e).name() << endl;
	cout << x << endl;
	*a = 20;
	cout << "*a = 20: " <<  x << endl;
	*b = 30;
	cout << "*b = 30: " <<  x << endl;
	c = 40;
	cout << "c = 40: " << x << endl;
	e = 50;
	cout << "e = 50: " << x << endl;
	return 0;
}

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

    #include <iostream>

using namespace std;

int main()
{
	auto a = 1, b = 2;   // 正确的 因为 a 和 b 是同一类型
	auto c = 2, d = 4.5; // 错误的 因为 c 和 d 不是同一类型
	                     // int c = 2, d = 4.5 一样
	return 0;
}

auto不能使用的场景：

  1. auto不能作为函数的参数(能用作返回，但不建议)

    #include <iostream>

using namespace std;

void test(auto a)
{}

int main()
{
	test(2);
	return 0;
}

  2. auto不能直接用来声明数组

    // auto 声明数组是错误的
#include <iostream>

using namespace std;

int main()
{
	auto b[] = { 3, 4, 5 };
	return 0;
}

for

  • 语法

    #include <iostream>

using namespace std;

int main()
{
	int arr[] = { 1, 2, 3, 4 };

	// 使用下标
	for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); i++) {
		cout << arr[i] << " ";
	}
	cout << endl;

	// 使用指针
	for (int* p = arr; p < arr + sizeof(arr) / sizeof(arr[0]); p++) {
		cout << *p << " ";
	}
	cout << endl;

    // 范围for
	// 使用简化
    // for循环后的括号由冒号分为两部分,第一部分是范围内用于迭代的变量，第二部分则表示被迭代的范围
    // 可以用continue来结束本次循环，也可以用break来跳出整个循环
	for (int x : arr) {
		cout << x << " ";
	}
	cout << endl;

	// 使用简化 和自己推导
	for (auto x : arr) {
		cout << x << " ";
	}
	cout << endl;
	return 0;
}

  • 范围for的使用条件

    1. for循环迭代的范围必须是确定的(对于类而言，应该提供begin和end的方法，begin和end就是for循环迭代的范围)
    2. 迭代的对象要实现++和==的操作

nullptr

在c++中空指针的三种方法：

  1. NULL

  2. 0(和NULL等价，在宏中被定义为#define NULL 0)

    #ifndef NULL
#ifdef __cplusplus
#define NULL 0
#else
#define NULL ((void *)0)
#endif
#endif

    #include <iostream>

using namespace std;

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

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

int main()
{
	// 前两个不同的类型 但产生的相同的结果
	f(0);          // f(int)
	f(NULL);       // f(int)
	f((int*)NULL); // f(int*)
	return 0;
}

  3. nullper:推荐使用

注：

  1. 在使用nullptr表示指针空值时，不需要包含头文件，因为nullptr是C++11作为新关键字引入的
  2. 在C++11中，sizeof(nullptr) 与 sizeof((void*)0)所占的字节数相同
  3. 为了提高代码的健壮性，在后续表示指针空值时建议最好使用nullptr
Dzu
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Flink 1.入门Demo详解
BITDDD小栈
12-28 3621
一.引言： Apach Flink 是全新的流处理系统，在Spark Straming的基础上添加了很多特性，主要在于其提供了基于时间和窗口计算的算子，并且支持有状态的存储和 Checkpoint 的重启机制，下面假设有多个温度传感器持续传输当前温度，Flink流处理需要每一段时间提供该时间段内的传感器平均温度。 二.依赖支持 项目是基于maven的scala项目，主要导入flink的scala依赖，如果是java需要另一套依赖： 1.scala <properties> .
1.入门.html
09-10
1.入门.html
TensorFlow1.x入门教程——统领篇
NLP翟
05-13 9584
TensorFlow1.x入门教程前言你将得到什么？系列文章地址后记 前言 TesnorFlow作为深度学习的代表性的框架在业界被广泛的使用，现在已经有1.x和2.x版本，由于1.x和2.x版本的差距较大（可以理解为Python2与Python3的差距），并且2.x版本较为新资源还较少，不少公司仍然使用TensorFlow1.x，维护的项目也是TensorFlow1.x开发的。所以本教程也围绕了TensorFlow1.x展开。 你将得到什么？ 本教程实战性较强，内容也相对简单容易上手。所以，适合初学者了解T
Three.js入门详解
萌兔兔MMQ！！
08-03 7993
对于没有相关基础的人来说，入门真的很难，Three.js 将入门的门槛降低了一大截，对 WebGL 进行封装，简化我们创建三维动画场景的过程。1. Three.js 掩盖了 3D 渲染的细节：Three.js 将 WebGL 原生 API 的细节抽象化，将 3D 场景拆解为网格、材质和光源（即它内置了图形编程常用的一些对象种类）。7. 内置文件格式支持：你可以使用流行的 3D 建模软件导出文本格式的文件，然后使用 Three.js 加载，也可以使用 Three.js 自己的 JSON 格式或二进制格式。..
Vue基础知识总结 1：Vue入门
热门推荐
学Java，找哪吒
06-23 8万+
Vue基础教程系列，打造精品专栏。
1.PS新手入门教程
Webwangbo的博客
04-27 5524
简单的ps教程，每天学一点，从无到有，从小白变成大神，学到就是赚到。（持续更新）
1.入门_EN1
08-08
1.入门_EN1
1.入门准备篇1
08-08
1.入门准备篇1
关于C++ ：1.入门知识
07-30
c++的入门知识第一篇
C++教学——从入门到精通 10.循环
QIPABOSHI的博客
04-24 366
一些事嘛，需要重复做，这就是循环在开始学之前我提一个事，最好先学Python再学C++，不然就会像我和piaojunhe_0825一样有C++后遗症，在Python里写了一个for(int i=0;i
C++ WebServer的细节理解
我的博客
04-22 620
在非阻塞模式下，如果 I/O 操作不能立即完成（例如，因为没有数据可读 或 写缓冲区满），系统不会让调用进程阻塞等待，而是立即返回一个错误（通常为 EAGAIN 或 EWOULDBLOCK）。先查询文件描述符 fd 当前的标志，然后将 O_NONBLOCK 标志加入其中，并通过 F_SETFL 来更新文件描述符，最终实现将该文件描述符切换为非阻塞模式。这意味着，如果没有待处理的连接请求（即没有客户端尝试连接到服务器），accept() 会一直阻塞，直到有新的连接请求到达或发生其他特定条件（如超时）为止。
笨蛋学C++【C++基础第六弹】
YSL_Monet的博客
04-24 811
定义类需要用到关键字 class，然后指定类的名称，类的主体是包含在一对花括号中，主体包含类的成员变量和成员函数class 类名{访问修饰符（public/protected/private）:成员变量;成员函数();
【C++风云录】精益求精：探索C++开发中的性能优化艺术
记录我的学习历程
04-21 1092
本文将介绍几个在C++开发中常用的性能分析工具和性能优化工具集，包括PerfTools、gperftools、Valgrind、Intel VTune、PAPI以及Boost.Profile。通过深入了解这些工具的功能和用途，读者可以更好地理解如何利用它们来提高代码的执行效率和资源利用率。
C++——初识模板
qq_74245477的博客
04-22 908
之前实现的数据结构，比如栈，我们为了便于修改存储的数据类型，通常使用typedef来重定义数据类型，但是这样有一个缺陷，会导致我们定义的栈存储的都是一种数据，如果同时需要两个栈，一个存储int，一个存储自定义类型，那么typedef就不管用了。比如：当用int类型使用函数模板时，编译器通过对实参类型的推演，将T确定为int类型，然后产生一份专门处理int类型的代码，对于字符类型也是如此。概念：函数模板代表了一个函数家族，该函数模板与类型无关，在使用时被参数化，根据实参类型产生函数的特定类型的版本。
理解C语言中的位操作和整数类型：一个温度传感器读取问题的解析
最新发布
qq_61637982的博客
04-24 233
当我们编写嵌入式系统的代码时，我们经常需要使用位操作来处理硬件设备的数据。然而，如果我们对C语言的位操作和整数类型不完全理解，可能会遇到一些难以理解的问题。在这篇博客中，我将通过一个实际的例子来解释这些概念，并提供一个解决方案。
C++中的抽象类
hh121386的博客
04-23 200
C++中的抽象类
LeetCode //C - 18. 4Sum
Made in Code
04-22 715
【代码】LeetCode //C - 18. 4Sum。
CSAPP | Lab2-Bomb Lab详细解析
wangs29的博客
04-24 1254
邪恶的邪恶博士在我们班的机器上安放了大量的“二元炸弹”。二进制炸弹是一个由一系列阶段组成的程序。每个阶段都要求你在 stdin 上键入一个特定的字符串。如果你键入了正确的字符串，那么这个阶段就会被拆除，炸弹就会进入下一个阶段。否则，炸弹会通过打印“ BOOM 然后终止。当每个阶段都被拆除时，炸弹就会被拆除。我们要处理的炸弹太多了，所以我们给每个学生一个炸弹去拆除。你们的任务，你们别无选择，只能接受，就是在due date前拆除炸弹。祝你好运，欢迎加入拆弹小组！
掉落回弹问题（C语言）
m0_67184754的博客
04-22 363
【代码】掉落回弹问题（C语言）
three.js入门
09-12
1. 首先，你可以访问Three.js的官方文档网站。这个网站包含了所有关于Three.js的详细文档和示例代码，是你学习的主要资源。 2. 如果你想深入学习Three.js，可以参考原作者的最新教程视频。这个视频教程将带你深入...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值