C++祖师爷在使用C语言时感觉到了不方便的一些点,于是一步一步改进优化,最后形成了C++
本文将盘点一下基于C的语法优化
我们在C语言中学过,对于一个变量有全局域
与局部域
那么对于一个变量的搜索的原则
:
编译器是从局部到全局的的过程寻找,没有就会报错
先来看这样一段代码:
#include
int rand = 10;
int main()
{
printf("%d\n", rand);
return 0;
}
运行时并不会报错,但是在包含头文件#include
后
原因:
由于展开头文件后有rand
函数与我们定义的全局变量在全局域
重名了,造成报错
这就引出了命名空间域
的概念
在C++中,变量、函数和后面要学到的类都是大量存在的,这些变量、函数和类的名称将都存在于全局作用域中,可能会导致很多冲突。使用命名空间的目的是对标识符的名称进行本地化,
以避免命名冲突或名字污染,namespace关键字的出现就是针对这种问题的。
在C++中,不仅有命名空间域
,还有类域(本文不做讨论)
C++中搜索的原则
:
不指定域:1、当前局部域 2、全局域
指定域 3、如果指定了,直接去指定域搜索
namespace test
{
//
int rand = 10;
int Add(int x, int y)
{
return x + y;
}
struct Node
{
struct Node* next;
int val;
};
}
namespace test
{
int rand = 10;
namespace _test
{
int Add(int x, int y)
{
return x + y;
}
}
}
这就要引出作用域限定符
的概念了::
共有三种使用场景:
注意:
当::
左值为空时,为指定全局去寻找,会跳过局部域
namespace test
{
int rand = 10;
}
int main()
{
printf("%d\n", test::rand);
return 0;
}
优缺点:
这种使用方式安全,但过于麻烦
namespace test
{
int rand = 10;
}
using namespace test;
int main()
{
printf("%d\n", rand);
return 0;
}
优缺点:
这种使用方式有隐患:
就比如上图代码这种场景下namespace就失去了意义
但胜在方便,我们平时做练习时只要避免重名就可以使用,但是做项目时是不可以展开的
那有没有推荐的一种呢
我们不将命名空间全部展开,只引入部分成员
using std::cout;
using std::endl;
int main()
{
int val = 10;
cout << val << endl;
return 0;
}
我们可以将iostream中常用的部分展开
对于C++的输入输出在这里我们只能浅显认识,只知道怎么使用就可以了
我们可以理解cout
就像是我们的控制台, <<
像是水流,
感性的理解就像是我们将想要输出的内容流向控制台
int main()
{
cout << "hello world\n";
return 0;
}
endl可以理解为一个换行
int main()
{
cout << "hello world" << endl;
return 0;
}
相当于我们的C语言的scanf
感性的理解就像是我们将想要输入的内容从控制台流入目标变量
int a = 0;
int b = 10;
cin >> a >> b;
//scanf("%d%d", &a, &b);
这两行代码可以达到一样的效果
优缺点:
无需类型的识别
对于小数精度的控制有些麻烦,可以直接使用printf进行替代
缺省函数是什么呢
void Func(int a = 0)
{
cout << a << endl;
}
int main()
{
Func(); // 没有传参时,使用参数的默认值
Func(10); // 传参时,使用指定的实参
return 0;
}
为什么会有这个概念呢?
假设我们有个场景,当前我们有个顺序表
A需要100个字节空间,但是B只要4个字节空间
若按照C语言的方法100字节空间的需要频繁扩容,影响效率,而使用缺省函数便可以解决这方便困扰
typedef struct SeqList
{
int* a;
int size;
int capacity;
}SeqList;
void InitList(SeqList* list, int cy = 4)
{
list->a = NULL;
list->capacity = cy;
list->size = 0;
}
int main()
{
//需要100字节的
SeqList list1;
InitList(&list1, 100);
//需要4字节的
SeqList list2;
InitList(&list2);
return 0;
}
缺省函数也有分类
意味着每一个参数都是缺省的
void Func(int a = 10, int b = 20, int c = 30)
{
cout<<"a = "<<a<<endl;
cout<<"b = "<<b<<endl;
cout<<"c = "<<c<<endl;
}
意味着只有部分参数时缺省的
void Func(int a, int b = 10, int c = 20)
{
cout<<"a = "<<a<<endl;
cout<<"b = "<<b<<endl;
cout<<"c = "<<c<<endl;
}
注意:
第二个注意点是什么意思呢?
例如在test.cpp:int func(int x = 10)
head.h:int func(int x = 10)
在声明与定义分离的情况下,会出现报错
正确写法:
test.cpp:int func(int x)
head.h:int func(int x = 10)
那么可不可以如下所示呢?
test.cpp:int func(int x = 10)
head.h:int func(int x)
但是否定的,原因在于我们在预处理时会展开头文件,编译时会检查你使用的函数有没有声明或定义,若是使用缺省函数
,就会产生找不到声明的情况,最终导致报错
重载的大白话就是重名函数,
函数重载:是函数的一种特殊情况,C++允许在同一作用域中声明几个功能类似的同名函数,这些同名函数的形参列表(参数个数 或 类型 或 类型顺序)不同,常用来处理实现功能类似数据类型不同的问题。
#include
using namespace std;
// 1、参数类型不同
int Add(int left, int right)
{
cout << "int Add(int left, int right)" << endl;
return left + right;
}
double Add(double left, double right)
{
cout << "double Add(double left, double right)" << endl;
return left + right;
}
// 2、参数个数不同
void f()
{
cout << "f()" << endl;
}
void f(int a)
{
cout << "f(int a)" << endl;
}
// 3、参数类型顺序不同
void f(int a, char b)
{
cout << "f(int a,char b)" << endl;
}
void f(char b, int a)
{
cout << "f(char b, int a)" << endl;
}
int main()
{
Add(10, 20);
Add(10.1, 20.2);
f();
f(10);
f(10, 'a');
f('a', 10);
return 0;
}
我们在实际的项目工程中会有多个头文件和源文件,
在程序的翻译过程中汇编阶段会形成每个项目文件相应的符号表,
由于我们在链接前都没有sum函数真正的地址,故需要再链接时去到对应的文件符号表去寻找合并,而C语言
在形成符号表时是以函数名形成的,因为同名函数没办法区分,并不能应对函数重载的的机制
。
而C++
为了对应此问题将产生的符号表以使用前缀+函数名+变量名第一个字符构成,这样就能应对函数重载
的问题
另外:如果两个函数函数名和参数是一样的,返回值不同是不构成重载的,因为调用时编译器没办法区分。
C语言的灵魂是指针,那么C++有没有能与之相应的功能呢?
答案是引用。
语法:类型& 引用变量名(对象名) = 引用实体;
void TestRef()
{
int a = 10;
int& ra = a;//<====定义引用类型
printf("%p\n", &a);
printf("%p\n", &ra);
}
我们对a变量引用,得到ra变量,都进行&打印得到相同的地址,故引用
引用不是新定义一个变量,而是给已存在变量取了一个别名,编译器不会为引用变量开辟内存空间,它和它引用的变量共用同一块内存空间。
void TestRef()
{
int a = 10;
// int& ra; // 该条语句编译时会出错
int& ra = a;
int& rra = a;
printf("%p %p %p\n", &a, &ra, &rra);
}
void TestConstRef()
{
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;
}
void Swap(int& left, int& right)
{
int temp = left;
left = right;
right = temp;
}
int& Count()
{
static int n = 0;
n++;
// ...
return n;
}
int& Add(int a, int b)
{
int c = a + b;
return c;
}
int main()
{
int& ret = Add(1, 2);
Add(3, 4);
cout << "Add(1, 2) is :"<< ret <<endl;
return 0;
}
注意:如果函数返回时,出了函数作用域,如果返回对象还在(还没还给系统),则可以使用引用返回,如果已经还给系统了,则必须使用传值返回。
在语法概念上引用就是一个别名,没有独立空间,和其引用实体共用同一块空间。
int main()
{
int a = 10;
int& ra = a;
cout<<"&a = "<<&a<<endl;
cout<<"&ra = "<<&ra<<endl;
return 0;
}
在底层实现上实际是有空间的,因为引用是按照指针方式来实现的。
int main()
{
int a = 10;
int& ra = a;
ra = 20;
int* pa = &a;
*pa = 20;
return 0;
}
我们来看下引用和指针的汇编代码对比:
那么引用可以代替指针吗?
答案是否定的。
例如在双向链表的场景中:我们要删除一个节点,因为引用是不能改变指向的。
更详细的一点说:当第一个next为下一个节点地址的引用时,如果我们要更改next,实际上是在修改下一个节点的地址,由于地址是个常量,不能被修改最终导致报错
总结:
注意:
底层上引用就是指针
在C语言的学习中,我们学习过宏,但是宏有比较多的缺点。
宏的缺点:
1、语法复杂,坑很多,不容易控制
2、不能调试
3、没有类型安全的检查
但是有时候宏又会很好用,在执行一些代码很短但又需多次调用的会很依赖。
所以有了内联函数的概念,他的用法与函数一样,但是会按函数中你定义的逻辑在你调用的地方展开(减少栈栈帧创建的过程),与宏函数直接替换是不一样的
使用时用inline修饰函数即可
// F.h
#include
using namespace std;
inline void f(int i);
// F.cpp
#include "F.h"
void f(int i)
{
cout << i << endl;
}
// main.cpp
#include "F.h"
int main()
{
f(10);
return 0;
}
// 链接错误:main.obj : error LNK2019: 无法解析的外部符号 "void __cdeclf(int)" (?f@@YAXH@Z),该符号在函数 _main 中被引用
关于最后一点,还有部分扩展。
当我们函数定义没有分离,都在F.h
中时;
int Add(int x, int y)
{
return x + y;
}
若我们在别的源文件#include
,会报重定义的错误,
原因在于头文件在预处理会展开,汇编时生成的符号表会由于函数相同而造成部分符号表相同,链接时就会报重定义的错误。
那么解决办法呢?