投稿
  1. 首页
  2. 随笔

C++入门-- 一篇带你扫清前期琐碎语法知识，快速入门，效率直线拉升

阿里云系统 • 2022-11-13 • 随笔 • 阅读 7

C++入门-- 一篇带你扫清前期琐碎语法知识，快速入门，效率直线拉升,第1张

C++入门-- 一篇带你扫清前期琐碎语法知识，快速入门，效率直线拉升

目录
  • C++关键字(C++98)
  • 命名空间
    • 命名空间定义：
    • 命名空间嵌套
  • using namespace std
  • C++输入和输出
  • 缺省参数
  • 函数重载
    • 总结：
  • 函数重载面试题
    • 1、为什么C语言不支持重载？C++底层是如何支持重载的
    • 2、extern " c "的作用是什么？
  • 引用概念
    • 引用特性
    • 常引用
    • 使用场景
      • 做参数
      • 引用做返回值，传值返回和传引用返回的区别
      • 总结：
    • 值和引用的作为返回值类型的性能比较
    • 引用和指针的区别
  • 内联函数
  • 面试题
  • auto关键字(C++11)
    • auto的使用规则
    • auto不能推导的场景
    • auto和for循环(C++11)搭配使用
    • 范围for的使用条件
  • 指针空值nullptr(C++11)

C++关键字(C++98)

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

命名空间

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

命名空间定义：

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

// 定义一个命名空间名是mzt，在命名空间中定义一个函数print() 
namespace mzt 
{
	void print() 
	{
		cout << "hello cppn" << endl;
		cout << "---------------------" << endl;
		cout << "hello cpp" << endl;
	}
}

注：endl和换行是一样的效果，所以在这里看起来第一行的hello cpp被换行两次

从主函数中想要调用print这个函数就必须要指定函数的具体位置是在哪，mzt::print() ,这句代码表示的是在一个名叫mzt这个命名空间的域中找出print()这个函数把它调用，

命名空间嵌套 
namespace mzt 
{
	void print() 
	{
		cout << "hello cppn" << endl;
		cout << "---------------------" << endl;
		cout << "hello cpp" << endl;
	}
	//当前命名空间mzt 中嵌套一个命名空间calculate
	namespace calculate
	{
	//mzt::calculate 域中
		int add(int x,int y) 
		{
			return x + y;
		}
	}
}

int main() 
{
	mzt::print();
	int ret = mzt::calculate::add(1, 2);
	return 0;
}

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

using namespace std

C++库为了防止命名冲突，把自己库里面的东西都定义在一个std的命名空间中，要使用标准库的东西，有三种方式：

1、指定命名空间 - 最规范

std:: cout<< " " << std:: endl;

2、把std命名空间整个展开 - 直接使用，虽然方便，容易命名冲突

using namespace std
cout<< " " << endl;

3、部分展开 - 只将cout和endl部分展开，可以直接使用，同样规范，不会命名冲突

using std::cout;
using std::endl;
C++输入和输出

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

#include
using std::cout;
using std::endl;
int main()
{
	std::cout << "Hello world!!!"<< std::endl;
	return 0; 
}

这句代码的意思是向控制台输出一个字符串，其中cout表示的就是控制台对象而endl表示的是换行，整体意思是将"Hello world!!!"输出到控制台打印并换行

对比于C语言printf和scanf的区别：

cout 和 cin有自动类型识别（原理：函数重载+运算符重载），不需要加格式控制符，使用起来也更为方便

#include
using std::cout;
using std::endl;

int main() 
{
	int a = 10;
	//仅分配一次指向p的值，对指针加const更安全
	const int* p = &a;

	std::cout << " a值打印前：" << a << endl;
	std::cin >> a;
	std::cout << " a值打印后：" << a << endl;
	return 0;
}

缺省参数

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

namespace mzt 
{
	void func(int a = 10)
	{
		if (a > 10)
		{
			std::cout << "hehe" << std::endl;
		}
		else 
		{
			std::cout << "haha" << std::endl;
		}
	}
}
int main() 
{
	//指定参数
	mzt::func(20);
	//使用默认参数
	mzt::func();
	return 0;
}

可以看到当不指定参数时，func()函数使用的是默认参数，而当指定参数时，func()函数使用的时指定参数

全缺省参数

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

半缺省参数：使用缺省参数时，要从右往左
 

void TestFunc(int a, int b = 10, int c = 20) 
{
 cout<< a < 

部分缺省和全缺省从直观上的区别
 

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

int main() 
{
	
	mzt::func(1);
	
	mzt::func(1,2);

	mzt::func(1,2,3);
	return 0;
}

 

从运行结果可以看出从左往右依次指定参数后缺省参数就不再起作用了，最后一行可以看出
 
 注意：声明和定义不能同时出现缺省参数
 

//test.h
void TestFunc(int a = 10);
// test.c
void TestFunc(int a = 20)
{}

 

 
 
如果声明和定义同时出现缺省参数会导致编译器犯糊涂，不知道该使用哪个缺省值，这个时候编译器就会报错了
 

 

总结：
 

  1. 半缺省参数必须从右往左依次来给出，不能间隔着给
  2. 缺省参数不能在函数声明和定义中同时出现
  3. 缺省参数的作用会使用起来变得更灵活
 
函数重载 

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

以下对重载函数的调用
 

namespace mzt 
{
	//参数类型是int
	void func(int x, int y)
	{
		cout << x << " " << y  << " "  << endl;
		cout << "调用：func(int x, int y)" << endl;
	}
	//参数个数只有一个
	void func(int x)
	{
		cout << x << endl;
		cout << "调用：func(int x)" << endl;
	}
	//参数类型是float
	void func(float x, float y)
	{
		cout << x << " " << y << " " << endl;
		cout << "调用：func(float x, float y)" << endl;
	}
	void func(double x,int y)
	{
		cout << x << " " << y << " " << endl;
		cout << "调用：func(double x,int y)" << endl;
	}
	void func(int x, double y)
	{
		cout << x << " " << y << " " << endl;
		cout << "调用：func(int x, double y)" << endl;
	}
}

int main() 
{
	mzt::func(1,2);
	//vs2019的检查严格，如果是以float类型传参的话小数点后面必须带f
	mzt::func(1.5f, 2.5f); 
	mzt::func(1);

	//类型顺序不同
	mzt::func(2, 6.8);
	mzt::func(4.5,6);

	return 0;
}

 

实际效果：
 
 
总结： 

函数重载必须是类型不同，或者参数个数不同，其次是类型顺序不同，但是返回值不构成函数重载
 
函数重载面试题 
1、为什么C语言不支持重载？C++底层是如何支持重载的 

在C语言中，编译器在编译过程会将我们的函数重命名，具体的方法就是在我们的函数名前加上“_“修饰符，通过这种方式就可以在我们的符号表种查找到了，但是假如有两个相同的函数，编译之后进行相同的重命名，在符号表中生成的函数名一样，那么就无法区分到底是哪个函数了，所以这也就是我们的C语言为什么不支持函数重载的原因了。
 
 结论：在linux下，采用gcc编译完成后，函数名字的修饰没有发生改变
 

 

结论：
 在linux下，采用g++编译完成后，函数名字的修饰发生改变，编译器将函数参数类型信息添加到修改后的名字中
 

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

候在C++工程中可能需要将某些函数按照C的风格来编译，在函数前加extern “C”，意思是告诉编译器，将该函数按照C语言规则来编译，假设张三同学使用C++实现了两个接口函数（add、swap），李四同学在他的工程中想要使用，但是李四同学使用的是C编程语言，那么当李四同学调用这两个接口函数的时候，就会出现链接错误，因为当李四同学去调用这两个函数的时候在链接阶段会去符号表里找Add函数和swap函数，而C++的函数名修饰规则和C语言的不一样，所以就会出现链接错误，解决办法对这两个函数加extern “c”，这样一来add函数和swap就不支持函数重载了
 

 
 
链接时报错：error LNK2019: 无法解析的外部符号_Add，该符号在函数 _main 中被引用
 

 
引用概念 

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

namespace quote
{
	void func() 
	{
		int a = 10;
		//为a取别名叫b
		int& b = a;
		b = 20;
		//为b取别名叫c
		int& c = b;
		c = 30;
	}
}

 

运行结果
 
 

 
 
从结果可以看出这里分别给a取了两个别名，并且别名值的改变也会影响变量a，因为别名本身代表的就是a，引用的细致探讨暂且先不管有了足够的基础支撑后再来研究
 

 

那如果是函数调用给实参取别名可以吗？
 

namespace quote
{
	void func() 
	{
		int a = 10;
		//为a取别名叫b
		int& b = a;
		b = 20;
		//为b取别名叫c
		int& c = b;
		c = 30;
	}
	//交换num1和num2的值
	void Swap(int &num1,int &num2) 
	{
		int tmp = num1;
		num1 = num2;
		num2 = tmp;
	}
}

 

答案是可以的，这也是在给实参取别名，通过引用的改变反馈给实参
 
 
引用特性 

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

void func() noexcept
	{
		int a = 10;
		//int& b;  //err，定义引用必须初始化
		int &b = a;//正确处理
	}

 

 

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

void func() noexcept
	{
		int a = 10;
		int &b = a;//正确处理
		int &c = a;
		int &d = a;
	}

 

 
 
给变量a取了三个小名，b、c、d
 

 

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

 
 
常引用的概念：被const修饰的引用就是常引用
 

 

void TestConstRef()
{
 const int a = 10;
 //int& ra = a; 
 //const修饰的变量不能直接赋值给非const修饰的引用，权限放大
 
 const int& ra = a;//ok，引用ra和变量a都被const修饰
 
 int& b = 10;
 //10是一个常量，将一个常量赋值给引用是不行的，
 //10实际上是一个临时对象,临时对象具有常属性
 //被const修饰的引用可以绑定到临时对象,而这里的引用并没有加const
 const int& b = 10;//ok
 
 double d = 12.34;//ok，隐士类型转换
 
 int& rd = d; 
 // 变量d会产生临时对象，非const引用不能绑定到临时对象，临时对象具有常属性
 
 const int& rd = d; 
 //ok，变量d会变成一个临时对象，
 //加const修饰的引用可以绑定到临时对象
 }

 
使用场景 
做参数 

int add(int& num1, int& num2) 
{
	 return num1 + num2;
}

 
引用做返回值，传值返回和传引用返回的区别 

 
 
传值返回，返回的是一个临时对象，临时对象需要被绑定到const引用
 

 

int add(int& num1, int& num2) 
{
	 int ret = num1 + num2;
	 return ret;	//局部变量随着函数栈帧销毁而销毁，
	 //这里为了将值带回去，会产生一个临时对象，
	 //返回的时候返回这个临时对象,临时对象可能会在寄存器中保存
}

int mian()
{
	int a = 10,b = 20;
	const int &sum = add(a, b);
	//sum引用去接受临时对象，临时对象具有常属性，需要const修饰的引用绑定到临时对象
	return 0;
}

 

 
 
传引用返回
 

 

int& add(int& num1, int& num2)
{
	int c = num1 + num2;
	return c;//返回的是变量c的引用
}

int main() 
{
	int a = 10, b = 20;
	int& ret = add(a,b);
	//返回左值引用，左值引用不具有常属性，不需要加const修饰
	cout << ret << endl;

	return 0;
}

 

 
 
需要注意的是这个ret的结果可能会是随机值，也可能会是30，因为c是一个局部变量，随着栈帧的销毁会一块销毁，当空间被销毁了，这块空间就会归还给 *** 作系统，程序员就没有使用权限了，而为什么是随机值，是因为这块空间可能会被清空置成随机值，感兴趣的同学可以在打印ret结果值前面加个printf，这样这块空间就彻底是随机值了
 

 
总结： 

传值返回，返回的是变量的拷贝，这是个临时对象，具有常属性
 传引用返回，返回的是变量的别名，可能会是随机值，也可能会是正确的值
 

进一步理解引用
 

int& add(int num1, int num2)
{
	int c = num1 + num2;
	return c;
}

int main() 
{
	
	int& ret = add(10,20);
	add(20, 30);
	cout << ret << endl;//50

	return 0;
}

 

 

 
 
当add函数被调用后，返回的是一个局部变量c的别名，而此时的ret引用已经绑定到这个变量c，第一次调用add函数的时候ret的值是30，第二次调用的时候ret的值被覆盖成50，因为ret引用是变量c的别名，c的改变也会影响到ret的值
 

 

总结：
 返回局部变量的引用不安全，可能会让结果变得不可预料，加上static关键字可以延长变量的生命周期，安全！
 
值和引用的作为返回值类型的性能比较 

struct A 
{ 
	int a[10000];
};
// 值返回
A TestFunc1(A a)
{ 
	return a;
}
// 引用返回
A& TestFunc2(A &a) 
{ 
	return a;
}

void Test()
{
	A a;
	// 值传递，值返回
	int begin1 = clock();
	for (int i = 0; i < 100000; ++i)
		TestFunc1(a);
	int end1 = clock();
	// 引用传递，引用返回
	int begin2 = clock();
	for (int i = 0; i < 100000; ++i)
		TestFunc2(a);
	int end2 = clock();
	// 耗时对比
	cout << "TestFunc1 time:" << end1 - begin1 << endl;
	cout << "TestFunc2 time:" << end2 - begin2 << endl;
}

int main() 
{
	Test();

	return 0;
}

 

 

 
 
传值调用和返回伴随着值拷贝的消耗，而传引用只是取别名，对比明显传引用效果更好
 

 
引用和指针的区别 

从语法上的理解：
 

void functest() 
{
	int b = 10;
	//为指针变量pa开辟四个字节,pa指针存放变量b的地址
	int* pa = &b;
	
	int c = 20;
	//为变量c单独取别名为d，不单独开辟空间，更有效
	int& d = c;
}


 

从汇编实现角度看待：
 引用的底层也是类似指针存地址的方式处理的，并不像是单纯取别名这样
 
 总结引用和指针的不同点:
 

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

内联函数的概念：
 我们知道C语言为了使一些代码仅少的函数减少建立栈帧的消耗，常常会使用宏函数支持，在预处理阶段就展开，而C++在处理的时候往往采用的是 inline 修饰的函数叫做内联函数，编译时C++编译器会在调用内联函数的地方展开，没有函数压栈的开销，内联函数提升程序运行的效率
 

频繁调用的小函数，建议定义成内联
 

特性：
 

  1. inline是一种以空间换时间的做法，省去调用函数额开销。所以代码很长或者有循环/递归的函数不适宜
     使用作为内联函数。
     .
  2. inline对于编译器而言只是一个建议，编译器会自动优化，如果定义为inline的函数体内有循环/递归等等，编译器优化时会忽略掉内联。
 

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

为什么C++需要提供内联函数呢？因为宏函数有许多的不足
 1、宏函数不支持调试
 2、宏函数语法复杂，易出错
 3、宏没有类型安全的检查
 

C++有哪些技术替代宏？
 

  1. 常量定义 换用const
  2. 函数定义 换用内联函数
 
auto关键字(C++11) 

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

int TestAuto()
{
 return 10; 
}

int mian()
{
	int a = 10;
	auto b = 12.5f;
	auto c = 102.5;
	auto d = TestAuto();
	//打印变量的类型
	cout << typeid(a).name() << endl;//int
	cout << typeid(b).name() << endl;//float
	cout << typeid(c).name() << endl;//double
	cout << typeid(d).name() << endl;//int
}

 

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

1、auto与指针和引用结合起来使用用auto声明指针类型时，
 用auto和auto*没有任何区别，但用auto声明引用类型时则必须加&
 

int x = 10;
	auto a = &x;	
	auto* b = &x;
	auto& c = x;	//不加引用类型auto推断的就是int了
	cout << typeid(a).name() << endl;//int *
	cout << typeid(b).name() << endl;//int *
	cout << typeid(c).name() << endl;//int 

 

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

auto a = 10, b = 30, c = 50;
auto pa = &a, pb = &b, pc = &c;
auto& ra = a, rb = b, rc = c;
auto c = 1, d = 4.0;
//err，推断第一个类型是int，推导出来的类型定义的变量却是double类型

 
auto不能推导的场景 

1、auto不能作为函数的参数
 

 
 
auto不能作为形参类型，因为编译器无法对a的实际类型进行推导
 

 

2、auto不能直接用来声明数组
 
auto和for循环(C++11)搭配使用 

for循环后的括号由冒号“ ：”分为两部分：第一部分是范围内用于迭代的变量，第二部分则表示被迭代的范围。
 

int arr[] = {1,2,3,4,5};
	//遍历打印
	for (auto e : arr) 
	{
		cout << e << " ";
	}
	cout << endl;
	//遍历修改
	for (auto &e : arr)
	{
		e *= 2;
	}
	//遍历打印
	for (auto e : arr)
	{
		cout << e << " ";
	}
	cout << endl;

 

与普通循环类似，可以用continue来结束本次循环，也可以用break来跳出整个循环
 
范围for的使用条件 

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

//假设外面传递的是一个数组的首地址，
//但是这里范围for并不能确定该数组的大小，强行使用只会报错
void TestFor(int *array)
{
	for(auto& e : array)
	cout<< e < 
指针空值nullptr(C++11) 

在写C程序的时候我们会经常用NULL初始化一个指针变量，防止他成为野指针，其实NULL实际上是一个宏，在预处理阶段会把他展开为(（void*)0)
 
 NULL可能被定义为字面常量0，或者被定义为无类型指针(void*)的常量。不论采取何种定义，在使用空值的指针时，都不可避免的会遇到一些麻烦比如以下：
 

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

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

int main()
{
	f(0);
	f(NULL);//NULL也是0,这样就产生歧义了
	return 0;
}


 

使用注意：
 

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


					

						
欢迎分享，转载请注明来源：内存溢出
原文地址: http://outofmemory.cn/zaji/4951488.html
赞 (0)
打赏 微信扫一扫 微信扫一扫 支付宝扫一扫 支付宝扫一扫
阿里云系统 阿里云系统 一级用户组
0 0
上一篇 2022-11-13
下一篇 2022-11-13

发表评论

登录后才能评论

评论列表（0条）

保存