百度搜索显示网站logo,在网站上做的h5如何发到微信上,seo专员是指什么意思,上海市建设工程 安全协会网站一、C 关键字#xff08;C98#xff09; C 总计 63 个关键字#xff0c;C 语言 32 个关键字。C 语言的关键字在 C 中继续可以使用。 C 兼容 C 的绝大多数语法。 二、命名空间 在 C / C 中#xff0c;变量、函数和类都是大量存在的#xff0c;这些变量、函数和类的名称将都…一、C 关键字C98 C 总计 63 个关键字C 语言 32 个关键字。C 语言的关键字在 C 中继续可以使用。 C 兼容 C 的绝大多数语法。 二、命名空间 在 C / C 中变量、函数和类都是大量存在的这些变量、函数和类的名称将都存在于全局作用域中可能会导致很多冲突。使用命名空间的目的是 对标识符的名称进行本地化以避免命名冲突或名字污染 namespace 关键字的出现就是针对这种问题的。 #include stdio.h
#include stdlib.hint rand 10;
// C语言没办法解决类似这样的命名冲突问题所以C提出了namespace来解决
int main()
{printf(%d\n, rand);return 0;
}
// 编译后报错error C2365: “rand”: 重定义以前的定义是“函数” 在不同的作用域中可以定义同名的变量但在同一作用域下不能定义同名的变量。 用命名空间来解决变量 rand 和 stdlib 库里的命名冲突。
#includestdio.h
#includestdlib.hnamespace yln // 定义了一个命名空间域
{int rand 10; // 定义变量int Add(int x, int y) // 定义函数{return x y; }struct Node // 定义结构体类型{struct Node* next;int val; };
}int main()
{printf(%p\n, rand);//函数指针printf(%d\n, yln::rand); // rand变量::叫做域作用限定符yln::Add(3, 5);//调用函数struct yln::Node node1; // 结构体return 0;
}1、命名空间的定义 定义命名空间需要使用到 namespace 关键字后面 命名空间的名字 然后 接一对 {} 即可{} 中即为命名空间的 成员 。 1正常的命名空间定义
namespace yln
{int rand 10; // 命名空间中可以定义变量int Add(int left, int right) // 命名空间中可以定义函数{return left right;}struct Node // 命名空间中可以定义类型{int val;struct Node* next;};
} yln 是命名空间的名字一般开发中是用项目名字做命名空间名。 2命名空间可以嵌套
// test.cpp
namespace N1
{int a;int b;int Add(int left, int right){return left right;}namespace N2{int c;int d;int Sub(int left, int right){return left - right;}}
}int main()
{printf(%d\n, N1::N2::Sub(10, 20)); // 访问嵌套命名空间return 0;
} 3同一个工程中允许存在多个相同名称的命名空间
// test.h
namespace N1
{int Mul(int left, int right){return left * right;}
} 同一个工程中的 test.h 和上面 test.cpp 中的两个 N1 会被编译器合并成在同一个命名空间中。 注意一个命名空间就定义了一个新的作用域命名空间中的所有内容都局限于该命名空间中。 2、命名空间的使用 命名空间的使用有三种方式 1加命名空间名称及作用域限定符 int main()
{printf(%d\n, N::a);return 0;
} ⚪优点不存在命名污染。 ⚪缺点如果要去访问多个命名空间里的东西时需要一一指定。 2使用 using 将命名空间中某个成员引入
using N::b;
int main()
{printf(%d\n, N::a);printf(%d\n, b);return 0;
} ⚪优点不会造成大面积的污染把常用的展开后也不需要一一指定。 3使用 using namespace 将命名空间名称引入
using namespace N;
int main()
{printf(%d\n, N::a);printf(%d\n, b);Add(10, 20);return 0;
} ⚪优点方便。 ⚪缺点自己定义的东西会暴露出去导致命名污染。 三、C 输入输出
#includeiostream
using namespace std;int main()
{cout Hello world! endl;return 0;
} std 是 C 标准库的命名空间名C 将标准库的定义实现都放到这个命名空间中。 使用 cout 标准输出对象控制台和 cin 标准输入对象键盘时必须包含 iostream 头文件以及按命名空间使用方法使用 std。 cout 和 cin 类似 C 语言的 printf 和 scanf这里先简单了解一下因为对于 C 语言中的 I/O 是函数而 C 是对象。cout 和 cin 是全局的流对象endl 是特殊的 C 符号表示换行输出他们都包含在包含 iostream 头文件中。 是流插入运算符 是流提取运算符。 使用 C 输入输出更方便不需要像 printf / scanf 输入输出时那样需要手动控制格式。 C 的输入输出可以自动识别变量类型。 实际上 cout 和 cin 分别是 ostream 和 istream 类型的对象 和 也涉及运算符重载等知识。 注意 早期标准库将所有功能在全局域中实现声明在 .h 后缀的头文件中使用时只需包含对应头文件即可后来将其实现在 std 命名空间下为了和 C 头文件区分也为了正确使用命名空间规定 C 头文件不带 .h 旧编译器 (vc 6.0) 中还支持 iostream.h 格式后续编译器已不再支持所以推荐使用 iostream std 的方式。 #include iostream
using namespace std;int main()
{int a;double b;char c;// 可以自动识别变量的类型cin a;cin b c;cout a endl;cout b c endl;return 0;
}关于 cout 和 cin 还有很多更复杂的用法比如控制浮点数输出精度控制整形输出进制格式等。但是因为 C 是兼容 C 语言的用法这些又用得不是很多所以我们一般可以直接用按照 C 语言的用法来写就不用再进一步学习 C 这方面的内容了。 std 命名空间的使用惯例 std 是 C 标准库的命名空间如何展开 std 使用更合理呢 在日常练习中建议直接 using namespace std 即可这样就很方便。 using namespace std 展开标准库就全部暴露出来了如果我们定义跟库重名的类型 / 对象 / 函数就存在冲突问题。该问题在日常练习中很少出现但是项目开发中代码较多、规模大就很容易出现这种情况。所以建议在项目开发中使用像 std::cout 这样使用时指定命名空间 using std::cout 展开常用的库对象 / 类型等方式。 #includeiostream// 展开常用即可工程项目中常见的对命名空间的用法
using std::cout;
using std::endl;int main()
{// 只要是库里的都得指定stdstd::cout Hello world! std::endl//cout Hello world! endl;return 0;
}四、缺省参数
1、概念 缺省参数 是声明或定义函数时为函数的参数指定一个缺省值。在调用该函数时如果没有指定实参则采用该形参的缺省值否则使用指定的实参。 void Func(int a 0)
{cout a endl;
}int main()
{Func(); // 没有传参时使用参数的默认值 - 0Func(10); // 传参时使用指定的实参 - 10return 0;
} 2、分类
1全缺省参数
void Func(int a 10, int b 20, int c 30)
{cout a a endl;cout b b endl;cout c c endl;
} 2半缺省参数
void Func(int a, int b 10, int c 20)
{cout a a endl;cout b b endl;cout c c endl;
} 注意 半缺省参数必须从右往左依次给出不能间隔着给。缺省参数不能在函数声明和定义中同时出现。 缺省值必须是 常量 或者 全局变量 。 C 语言不支持编译器不支持。 // test.h
void Func(int a 10);// test.cpp
void Func(int a 20)
{} 注意如果声明与定义位置同时出现恰巧两个位置提供的值不相同那么编译器就无法确定到底该用那个缺省值。 五、函数重载
1、概念 函数重载 是函数的一种特殊情况C 允许在同一作用域中声明几个功能类似的同名函数这些同名函数的形参列表参数个数 / 类型 / 类型顺序不同常用来处理实现 功能类似数据类型不同 的问题。 1参数类型不同
// test1.cpp
#include iostream
using namespace std;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参数类型顺序不同
// test2.cpp
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;
} 2、C支持函数重载的原理 -- 名字修饰 (name Mangling)
为什么C支持函数重载而C语言不支持函数重载呢 在 C / C 中一个程序要运行起来需要经历以下几个阶段预处理、编译、汇编、链接。 可参考【C语言】程序环境预处理 -- 详解_炫酷的伊莉娜的博客-CSDN博客 内有详细介绍。 实际项目通常是由多个头文件和多个源文件构成而通过 C 语言阶段学习的编译链接我们 知道当前 test2.cpp 中调用了 test1.cpp 中定义的 Add 函数在编译后链接前test2.o 的目标文件中没有 Add 的函数地址因为 Add 是在 test1.cpp 中定义的所以 Add 的地址在 test1.o 中那该怎么办呢 所以链接阶段就是专门处理这种问题链接器看到 test2.o 调用 Add但是没有 Add 的地址就会到 test1.o 的符号表中找 Add 的地址然后链接到一起。 那么在链接时面对 Add 函数链接接器会使用哪个名字去找呢这里每个编译器都有自己的函数名修饰规则。由于 Windows 下 VS 的修饰规则过于复杂而 Linux 下 G 的修饰规则简单易懂下面我们使用了 G 演示了这个修饰后的名字。 1采用 C 语言编译器编译后的结果 结论 在 Linux 下采用 GCC 编译完成后函数名字的修饰没有发生改变函数名相同时无法区分函数。 2采用 C 编译器编译后的结果 结论 在 Linux 下采用 G 编译完成后函数名字的修饰发生改变编译器将函数参 数类型信息添加到修改后的名字中。 补充通过上面我们可以看出 GCC 的函数修饰后名字不变而 G 的函数修饰后变成 _Z 函数长度 函数名 类型首字母。 以 Add 函数为例 _Z 是 GCC 编译器的修饰前缀表示这是一个 C 函数名。 3 是函数名的长度。 Add 是函数名。 ii / dd 是函数参数类型的首字母如果是 int* i那么就是 Pi。 3Windows 下名字的修饰规则 【总结】 通过这里就理解了 C 语言没办法支持重载因为同名函数没办法区分。而 C 是通过函数修饰规则来区分只要参数不同修饰出来的名字就不一样就支持了重载。如果两个函数的函数名和参数是一样的返回值不同是不构成重载的因为调用时编译器没办法区分。 4extern C
有时候在 C 工程中可能需要将某些 (部分) 函数按照 C 的风格来编译在函数前加 extern “C”意思是告诉编译器将该函数按照 C 语言规则来编译。比如tcmalloc 是 google 用 C 实现的一个项目他提供 tcmallc() 和 tcfree两个接口来使用但如果是 C 项目就没办法使用那么他就使用 extern “C” 来解决。
extern C int Add(int left, int right);int main()
{Add(1,2);return 0;
}C 项目可以调用 C 库也可以调用 C 的库C 是直接兼容 C 的。C 项目可以调用 C 库也可以使用 extern C 调用 C 库C 提供的函数加上 extern C。 六、引用
1、引用概念 引用 不是新定义一个变量而是给已 存在变量 取了一个 别名 编译器不会为引用变量开辟内存空间它和它引用的变量共用同一块内存空间。 类型 引用变量名对象名 引用实体
void TestRef()
{int a 10;int ra a;printf(%p\n, a);printf(%p\n, ra);// 地址相同
} 注意引用类型必须和引用实体是同种类型的。 2、引用特性 引用在定义时必须初始化。一个变量可以有多个引用。引用一旦引用一个实体就再不能引用其他的实体。 void TestRef()
{int a 10;// int ra; // 编译出错 - 没有对引用变量进行初始化// 可以有多个引用int ra a;int rra a;printf(%p %p %p\n, a, ra, rra);
} 3、常引用
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;
} 在 C 中引用必须与其引用的对象具有相同的类型或者可以通过隐式类型转换来匹配。 函数传参如果想减少拷贝使用引用传参如果函数中不改变这个参数最好使用 const 引用传参。const 引用的好处是保护实参避免被误改且它可以传普通对象也可以传 const 对象。 4、使用场景
1做参数
void Swap(int left, int right)
{int temp left;left right;right temp;
} 2做返回值
int Count()
{static int n 0;n;// ...return n;
}
int Add(int a, int b)
{int c a b;return c; // 函数结束后c变量就没有意义了
}int main()
{int ret Add(1, 2); // 引用Add函数返回值Add(3, 4);cout Add(1, 2) is : ret endl; // 7// 具体得看平台销毁栈帧时是否会清理栈帧空间但是这种写法本身就是越界的是错误的return 0;
} 函数运行时系统需要给该函数开辟独立的栈空间用来保存该函数的形参局部变量以及一些寄存器信息等。函数运行结束后该函数对应的栈空间就被系统回收了。空间被回收指该块栈空间暂时不能使用但是内存本身还在。 注意 如果函数返回时出了函数的作用域如果返回对象还在还没还给系统则可以使用引用返回如果已经还给系统了则必须使用传值返回。 5、传值、传引用比较
1传值、传引用的效率比较
#include time.hstruct A{int a[10000];
};void TestFunc1(A a)
{}
void TestFunc2(A a)
{}
void TestRefAndValue()
{A a;// 1、以值作为函数参数size_t begin1 clock();for (size_t i 0; i 10000; i){TestFunc1(a);}size_t end1 clock();// 2、以引用作为函数参数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;
} 以值作为参数或者返回值类型在传参和返回期间函数不会直接传递实参或者将变量本身直接返回而是传递实参或者返回变量的一份临时的拷贝因此用值作为参数或者返回值类型效率是非常低下的尤其是当参数或者返回值类型非常大时效率就更低。 2值和引用的作为返回值类型的性能比较
#include time.hstruct A{int a[10000];
};A a;A TestFunc1() // 值返回
{return a;
}
A TestFunc2() // 引用返回
{return a;
}void TestReturnByRefOrValue()
{// 1、以值作为函数的返回值类型size_t begin1 clock();for (size_t i 0; i 100000; i){TestFunc1();}size_t end1 clock();// 2、以引用作为函数的返回值类型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;
} 通过上述代码运行后的结果比较发现传值和指针在作为传参以及返回值类型上效率相差很大。 6、引用和指针的区别 在语法概念上引用就是一个别名没有独立空间和其引用实体共用同一块空间。 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;
} 引用和指针的汇编代码对比 【引用和指针的不同点】 引用概念上定义一个变量的别名指针存储一个变量地址。 引用在定义时必须初始化指针没有要求。引用在初始化时引用一个实体后就不能再引用其他实体而指针可以在任何时候指向任何一个同类型实体。 没有 NULL 引用但有 NULL 指针。 在 sizeof 中含义不同引用结果为引用类型的大小但指针始终是地址空间所占字节个数32位平台下占4个字节64 位平台下占 8 个字节 。 引用自加即引用的实体增加 1指针自加即指针向后偏移一个类型的大小。 有多级指针但是没有多级引用。 访问实体方式不同指针需要显式解引用引用是编译器自己处理。 引用比指针使用起来相对更安全指针容易出现野指针、空指针等非法访问问题。 七、内联函数
1、概念 以 inline 修饰的函数叫做 内联函数 编译时 C 编译器会在调用内联函数的地方展开没有函数调用建立栈帧的开销内联函数提升程序运行的效率。 如果在上述函数前增加 inline 关键字将其改成内联函数在编译期间编译器会用函数体替换函数的调用。 查看方式 在 release 模式下查看编译器生成的汇编代码中是否存在 call Add。在 debug 模式下需要对编译器进行设置否则不会展开因为在 debug 模式下编译器默认不会对代码进行优化下面给出 VS2019 的设置方式。 2、特性 inline 是一种以空间换时间的做法如果编译器将函数当成内联函数处理在编译阶段会用函数体替换函数调用缺陷可能会使目标文件变大优势少了调用开销提高程序运行效率。 inline 对于编译器而言只是一个建议不同编译器关于 inline 实现机制可能不同一般建 议将函数规模较小即函数不是很长具体没有准确的说法取决于编译器内部实现、不是递归、且频繁调用的函数采用 inline 修饰否则编译器会忽略 inline 特性。下图为 《Cprime》 第五版关于 inline 的建议inline 不建议声明和定义分离分离会导致链接错误。因为 inline 被展开就没有函数地址了链接就会找不到。 // test.h
#include iostream
using namespace std;inline void f(int i);// test.cpp
#include test.hvoid f(int i)
{cout i endl;
}// main.cpp
#include test.hint main()
{f(10);return 0;
} 链接错误main.obj : error LNK2019: 无法解析的外部符号 void __cdecl f(int) (?fYAXHZ)该符号在函数 _main 中被引用。 【回顾】宏的优缺点 优点 增强代码的复用性。 提高性能。 缺点 不方便调试宏。因为预编译阶段进行了替换 导致代码可读性差可维护性差容易误用。 没有类型安全的检查 。 C 有哪些技术替代宏 常量定义换用 const enum 。短小函数定义换用内联函数。 八、auto关键字C11
1、类型别名思考
由于接触到的程序愈变复杂导致类型难于拼写 含义不明确导致容易出错。
#include string
#include mapint main()
{std::mapstd::string, std::string m{ { apple, 苹果 }, { orange, 橙子 }, {pear,梨} };std::mapstd::string, std::string::iterator it m.begin();while (it ! m.end()){//....}return 0;
}
std::mapstd::string, std::string::iterator 是一个类型但是该类型太长了很容易写错我们可以通过 typedef 给类型取别名比如
#include string
#include maptypedef std::mapstd::string, std::string Map;int main()
{Map m{ { apple, 苹果 },{ orange, 橙子 }, {pear,梨} };Map::iterator it m.begin();while (it ! m.end()){//....}return 0;
}
使用 typedef 给类型取别名确实可以简化代码但是 typedef 有会遇到新的难题
typedef char* pstring;int main()
{const pstring p1;const pstring* p2;return 0;
} 编译结果失败。在上述代码中pstring 被定义为指向 char 类型的指针而 const pstring p1; 则表示 p1 是一个常量指针指向的值不能更改。然而在定义常量指针时必须给它进行初始化而这里没有对 p1 进行初始化因此会导致编译失败。同样地const pstring* p2; 表示 p2 是一个指向常量指针的指针同样需要进行初始化。编译器会报错提示缺少初始化。 在编程时常常需要把表达式的值赋值给变量这就要求在声明变量的时候清楚地知道表达式的 类型。 2、auto简介 在早期 C / C 中 auto 的含义是使用 auto 修饰的变量是具有自动存储器的局部变量但遗憾的是一直没有人去使用它为什么呢 因为在 C / C 中如果没有使用任何存储类别关键字如 auto、static、extern 等则变量默认为自动存储类别。因此使用 auto 关键字对于自动存储类别的变量来说没有实际意义。 C11 中标准委员会赋予了 auto 全新的含义即auto 不再是一个存储类型指示符而是作为一 个新的类型指示符来指示编译器auto 声明的变量必须由编译器在编译时期推导而得。 int TestAuto()
{return 10;
}int main()
{int a 10;auto b a;auto c a;auto d TestAuto();cout typeid(b).name() endl; // intcout typeid(c).name() endl; // charcout typeid(d).name() endl; // int// auto e; 无法通过编译使用auto定义变量时必须对其进行初始化return 0;
} 注意 使用 auto 定义变量时必须对其进行初始化 在编译阶段编译器需要根据初始化表达式来推导 auto 的实际类型。因此 auto 并非是一种“类型”的声明而是一个类型声明时的“占位符”编译器在 编译 期会将 auto 替换为变量实际的类型。 3、auto的使用细则
1auto与指针和引用结合起来使用 用 auto 声明指针类型时 用 auto 和 auto* 没有任何区别 但用 auto 声明引用类型 时则必须 加 。 int main()
{int x 10;auto a x;auto* b x;auto c x;cout typeid(a).name() endl; // int*cout typeid(b).name() endl; // int*cout typeid(c).name() endl; // int*a 20;*b 30;c 40;return 0;
} 2在同一行定义多个变量 当在同一行声明多个变量时这些变量必须是相同的类型否则编译器将会报错。因为 编译 器实际只对第一个类型进行推导 然后用推导出来的类型来定义其他的变量。 void TestAuto()
{auto a 1, b 2; // 编译成功auto c 3, d 4.0; // 编译失败因为c和d的初始化表达式类型不同
} 3auto不能推导的场景
auto 不能作为函数的参数。 void TestAuto(auto a)
{}
// 编译失败auto不能作为形参类型因为编译器无法对a的实际类型进行推导 auto 不能直接用来声明数组。 void TestAuto()
{int a[] {1, 2, 3};auto b[] {456}; // error
} 为了避免与 C98 中的 auto 发生混淆C11 只保留了 auto 作为类型指示符的用法。auto 在实际中最常见的优势用法就是跟以后会讲到的 C11 提供的新式 for 循环还有在 lambda 表达式等进行配合使用。 九、基于范围的for循环C11
1、范围for的语法
在 C98 中如果要遍历一个数组可以按照以下方式进行
void TestFor()
{int array[] {1, 2, 3, 4, 5};for (int i 0; i sizeof(array) / sizeof(array[0]); i){array[i] * 2;}for (int* p array; p array sizeof(array)/ sizeof(array[0]); p){cout *p endl;}
} 对于一个有范围的集合而言由程序员来说明循环的范围是多余的有时候还会容易犯错误。因 此 C11 中引入了基于范围的 for 循环。for 循环后的括号由冒号 : 分为两部分第一部分是 范围内用于迭代的变量 第二部分则表示 被迭代的范围 。 void TestFor()
{int array[] {1, 2, 3, 4, 5};for(auto e : array){e * 2;}for(auto e : array){cout e ;}return 0;
} 注意与普通循环类似可以用 continue 来结束本次循环也可以用 break 来跳出整个循环。 2、范围for的使用条件
1for循环迭代的范围必须是确定的 对于数组而言就是数组中第一个元素和最后一个元素的范围对于类而言应该提供 begin 和 end 的方法begin 和 end 就是 for 循环迭代的范围。 void TestFor(int array[])
{for(auto e : array) // 该代码有问题因为for的范围不确定{cout e endl;}
} 2迭代的对象要实现 和 的操作 十、指针空值nullptrC11 ⚪C98 中的指针空值 在良好的 C / C 编程习惯中声明一个变量时最好给该变量一个合适的初始值否则可能会出现 不可预料的错误比如未初始化的指针。如果一个指针没有合法的指向我们基本都是按照如下方式对其进行初始化 void TestPtr()
{int* p1 NULL;int* p2 0;// ……
} NULL 实际是一个宏在传统的 C 头文件stddef.h中可以看到如下代码 #ifndef NULL
#ifdef __cplusplus
#define NULL 0
#else
#define NULL ((void *)0)
#endif
#endif 可以看到NULL 可能被定义为字面常量 0或者被定义为无类型指针 (void*) 的常量。不论采取何种定义在使用空值的指针时都不可避免的会遇到一些麻烦比如 void f(int)
{cout f(int) endl;
}void f(int*)
{cout f(int*) endl;
}int main()
{f(0);f(NULL);f((int*)NULL);return 0;
} 程序本意是想通过 f(NULL) 调用指针版本的 f(int*) 函数但是由于 NULL 被定义成 0因此与程序的初衷相悖。在 C98 中字面常量 0 既可以是一个整形数字也可以是无类型的指针 (void*) 常量但是编译器默认情况下将其看成是一个整形常量如果要将其按照指针方式来使用必须对其进行强转 (void*)0 。 注意 在使用 nullptr 表示指针空值时不需要包含头文件因为 nullptr 是 C11 作为新关键字引入的。在 C11 中sizeof(nullptr) 与 sizeof((void*)0) 所占的字节数相同。 为了提高代码的健壮性在后续表示指针空值时建议最好使用 nullptr。
