我想做个网站怎么做 找谁做好,做渠道该从哪些网站入手,中国室内设计装饰协会,xhinacd.wordpress目录
编辑
1.C关键字
2. 命名空间
2.1 命名空间定义
2.2 命名空间使用
命名空间的使用有三种方式#xff1a;
注意事项
3. C输入输出
示例 1#xff1a;基本输入输出
示例 2#xff1a;读取多个值
示例 3#xff1a;处理字符串输入
示例 4#xff1a;读… 目录
编辑
1.C关键字
2. 命名空间
2.1 命名空间定义
2.2 命名空间使用
命名空间的使用有三种方式
注意事项
3. C输入输出
示例 1基本输入输出
示例 2读取多个值
示例 3处理字符串输入
示例 4读取整行字符串
示例 5错误输出和日志输出
输入输出流的格式化
示例 6设置小数位数
示例 7对齐输出
综合示例简单的交互程序
4.缺省参数
4.1 缺省参数概念
4.2 缺省参数分类
注意事项
5. 函数重载
5.1 函数重载概念
5.2 C支持函数重载的原理 -- 名字修饰 (Name Mangling)
结论
6. 引用
6.1 引用概念
6.2 引用特性
1.引用在定义时必须初始化
2.一个变量可以有多个引用
3.引用一旦引用一个实体再不能引用其他实体
6.3 常引用
6.4 使用场景
1.做参数
2.做返回值
6.5 传值、传引用效率比较
6.6 引用和指针的区别
7. 内联函数
7.1 概念
7.2 特性
以空间换时间
编译器建议
3.声明和定义不分离
7.3 内联函数的使用建议
8. auto 关键字
8.1 类型别名思考
8.2 auto 简介
8.3 auto 的使用细则
1.auto 与指针和引用结合使用
2.在同一行定义多个变量
8.4 auto 不能推导的场景
1.auto 不能作为函数的参数
2.auto 不能直接用来声明数组
3.为了避免与 C98 中的 auto 混淆C11 只保留了 auto 作为类型指示符的用法
4.auto 最常见的优势用法是与 C11 提供的新式 for 循环和 lambda 表达式配合使用
9. 基于范围的 for 循环
9.1 范围 for 的语法
9.2 范围 for 的使用条件
循环迭代的范围必须是确定的
迭代的对象要实现 和 的操作
10. 指针空值 nullptr
10.1 C98 中的指针空值
10.2 nullptr 简介
注意 1.C关键字 C总计63个关键字C语言32个关键字 ps下面我们只是看一下C有多少关键字不对关键字进行具体的讲解。后面我们学到以后再 细讲。
2. 命名空间 在C/C中变量、函数和后面要学到的类都是大量存在的这些变量、函数和类的名称将都存 在于全局作用域中可能会导致很多冲突。使用命名空间的目的是对标识符的名称进行本地化 以避免命名冲突或名字污染namespace关键字的出现就是针对这种问题的。
#include stdio.h
#include stdlib.h
int rand 10;
// C语言没办法解决类似这样的命名冲突问题所以C提出了namespace来解决
int main()
{
printf(%d\n, rand);
return 0;
}
// 编译后后报错error C2365: “rand”: 重定义以前的定义是“函数”
2.1 命名空间定义 定义命名空间需要使用到namespace关键字后面跟命名空间的名字然后接一对{}即可{} 中即为命名空间的成员。
// bit是命名空间的名字一般开发中是用项目名字做命名空间名。
// 大家下去以后自己练习用自己名字缩写即可如张三zs// 1. 正常的命名空间定义
namespace bit
{// 命名空间中可以定义变量/函数/类型int rand 10;int Add(int left, int right){return left right;}struct Node{struct Node* next;int val;};
}// 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;}} // namespace N2
} // namespace N1// 3. 同一个工程中允许存在多个相同名称的命名空间编译器最后会合成同一个命名空间中。
// ps一个工程中的test.h和上面test.cpp中两个N1会被合并成一个
// test.h
namespace N1
{int Mul(int left, int right){return left * right;}
} // namespace N1注意一个命名空间就定义了一个新的作用域命名空间中的所有内容都局限于该命名空间中
2.2 命名空间使用 命名空间中成员该如何使用呢 比如
#include iostream // 引入iostream以使用std::cout和std::endlnamespace bit
{// 命名空间中可以定义变量/函数/类型int a 0;int b 1;int Add(int left, int right){return left right;}struct Node{struct Node* next;int val;};
}int main()
{// 使用命名空间中的变量需要加上命名空间前缀// 编译报错error C2065: “a”: 未声明的标识符std::cout bit::a std::endl;return 0;
}命名空间的使用有三种方式
1.加命名空间名称及作用域限定符 这是最为明确的方式通过加上命名空间名称和作用域限定符 :: 来访问命名空间中的成员。
#include iostreamnamespace bit {int a 10;int b 20;int Add(int left, int right) {return left right;}
}int main() {// 使用命名空间名称及作用域限定符std::cout a: bit::a std::endl;std::cout b: bit::b std::endl;std::cout Add: bit::Add(3, 4) std::endl;return 0;
}2.使用using将命名空间中某个成员引入
使用 using 关键字可以将命名空间中的某个成员引入当前作用域之后可以直接使用该成员。
#include iostreamnamespace bit {int a 10;int b 20;int Add(int left, int right) {return left right;}
}int main() {// 使用using将命名空间中某个成员引入using bit::a;using bit::Add;std::cout a: a std::endl;// 使用被引入的成员不需要加命名空间前缀std::cout Add: Add(3, 4) std::endl;// 需要加命名空间前缀访问其他成员std::cout b: bit::b std::endl;return 0;
}3.使用using namespace 命名空间名称 引入
使用 using namespace 关键字可以将整个命名空间引入当前作用域之后可以直接使用命名空间中的所有成员。
#include iostreamnamespace bit {int a 10;int b 20;int Add(int left, int right) {return left right;}
}int main() {// 使用using将命名空间中某个成员引入using bit::a;using bit::Add;std::cout a: a std::endl;// 使用被引入的成员不需要加命名空间前缀std::cout Add: Add(3, 4) std::endl;// 需要加命名空间前缀访问其他成员std::cout b: bit::b std::endl;return 0;
}注意事项
加命名空间名称及作用域限定符这种方式最为安全和明确避免了命名冲突。使用 using 将命名空间中某个成员引入适用于只需要频繁使用命名空间中的某几个成员的情况。使用 using namespace 引入整个命名空间简单快捷但容易引发命名冲突尤其是在大型项目中使用多个命名空间时。
根据实际需要选择合适的方式使用命名空间有助于代码的组织和可读性。 3. C输入输出
在C中标准输入和输出通过标准库 iostream 提供。常用的输入输出流对象包括
std::cin标准输入流用于从键盘读取输入。std::cout标准输出流用于向屏幕输出信息。std::cerr标准错误流用于向屏幕输出错误信息。std::clog标准日志流用于向屏幕输出日志信息。
以下是一些常见的输入和输出操作的示例。
示例 1基本输入输出
#include iostreamint main() {int number;std::cout 请输入一个整数: ; // 输出提示信息std::cin number; // 从键盘读取输入到变量numberstd::cout 您输入的整数是: number std::endl; // 输出输入的值return 0;
}std::cout 使用 操作符将字符串和变量输出到控制台。std::cin 使用 操作符从控制台读取输入到变量。
示例 2读取多个值
#include iostreamint main() {int a, b;std::cout 请输入两个整数: ;std::cin a b;std::cout 您输入的整数是: a 和 b std::endl;return 0;
}可以使用多个 操作符连续读取多个值。
示例 3处理字符串输入
#include iostream
#include stringint main() {std::string name;std::cout 请输入您的姓名: ;std::cin name;std::cout 您好, name ! std::endl;return 0;
}
对于单词输入std::cin 可以直接读取到 std::string 变量中。
示例 4读取整行字符串
#include iostream
#include stringint main() {std::string line;std::cout 请输入一行文字: ;std::getline(std::cin, line);std::cout 您输入的是: line std::endl;return 0;
}
std::getline 函数用于读取一整行输入包括空格。
示例 5错误输出和日志输出
#include iostreamint main() {int a;std::cout 请输入一个正整数: ;std::cin a;if (a 0) {std::cerr 错误: 输入的不是正整数! std::endl;} else {std::clog 输入的正整数是: a std::endl;}return 0;
}
std::cerr 用于输出错误信息。std::clog 用于输出日志信息。
输入输出流的格式化
C 提供了一些操作符和函数来格式化输入输出例如控制小数位数、对齐等。
示例 6设置小数位数
#include iostream
#include iomanip // 引入iomanip库int main() {double pi 3.141592653589793;std::cout 默认输出: pi std::endl;std::cout std::fixed std::setprecision(2);std::cout 设置两位小数: pi std::endl;return 0;
}
std::fixed 和 std::setprecision 用于设置小数位数。
示例 7对齐输出
#include iostream
#include iomanipint main() {std::cout std::setw(10) 列1 std::setw(10) 列2 std::endl;std::cout std::setw(10) 123 std::setw(10) 456 std::endl;std::cout std::setw(10) 78 std::setw(10) 91011 std::endl;return 0;
}
std::setw 用于设置字段宽度实现对齐输出。
综合示例简单的交互程序
#include iostream
#include stringint main() {std::string name;int age;double salary;std::cout 请输入您的姓名: ;std::getline(std::cin, name);std::cout 请输入您的年龄: ;std::cin age;std::cout 请输入您的工资: ;std::cin salary;std::cout std::fixed std::setprecision(2);std::cout 姓名: name std::endl;std::cout 年龄: age 岁 std::endl;std::cout 工资: $ salary std::endl;return 0;
}
4.缺省参数
4.1 缺省参数概念
缺省参数是在声明或定义函数时为函数的参数指定一个默认值。在调用该函数时如果没有传递相应的实参则使用该参数的默认值否则使用传递的实参。
例子
#include iostream// 定义带缺省参数的函数
void PrintMessage(std::string message Hello, World!) {std::cout message std::endl;
}int main() {PrintMessage(); // 使用缺省参数输出 Hello, World!PrintMessage(Hello, C!); // 使用指定的实参输出 Hello, C!return 0;
}4.2 缺省参数分类
缺省参数可以分为全缺省参数和半缺省参数。 全缺省参数 所有参数都有缺省值的函数。 例子 #include iostream// 定义带全缺省参数的函数
void Display(int a 1, int b 2) {std::cout a a , b b std::endl;
}int main() {Display(); // 使用缺省参数输出 a 1, b 2Display(5); // 第一个参数使用指定值第二个参数使用缺省值输出 a 5, b 2Display(3, 4); // 使用指定的实参输出 a 3, b 4return 0;
}2.半缺省参数 部分参数有缺省值的函数。通常缺省参数应从右往左定义即后面的参数有缺省值前面的没有。 例子 #include iostream// 定义带半缺省参数的函数
void Show(int a, int b 10) {std::cout a a , b b std::endl;
}int main() {Show(5); // 第一个参数使用指定值第二个参数使用缺省值输出 a 5, b 10Show(3, 7); // 使用指定的实参输出 a 3, b 7return 0;
}注意事项
1.顺序缺省参数必须从右向左依次定义不能间隔定义。例如void func(int a 1, int b); 是不允许的因为 b 没有缺省值而 a 有。
// 错误示例
void func(int a 1, int b); // 不允许的b 没有缺省值// 正确示例
void func(int a, int b 2); // 正确的b 有缺省值2.声明和定义缺省参数只能在函数声明或定义中的一个地方出现不能在两个地方都定义缺省值。
// 错误示例
void func(int a 1, int b 2); // 在声明中定义了缺省参数void func(int a 1, int b 2) { // 在定义中又定义了缺省参数这是错误的// function body
}// 正确示例
void func(int a 1, int b 2); // 在声明中定义了缺省参数void func(int a, int b) { // 在定义中使用声明中的缺省参数// function body
}3.缺省值必须是常量或全局变量缺省值必须是一个常量或全局变量不能是局部变量或表达式的结果。
const int default_value 5;// 正确示例
void func(int a, int b default_value);// 错误示例
void func(int a, int b a 1); // 不允许缺省值不能是表达式的结果4.C语言不支持缺省参数缺省参数是C的特性C语言不支持缺省参数。
通过使用缺省参数可以使函数调用更加简洁避免在多次调用中重复传递相同的实参。 5. 函数重载
在自然语言中一个词可以有多重含义人们可以通过上下文来判断该词的真实含义即该词被重载了。比如关于体育项目的笑话“乒乓球是‘谁也赢不了’我们赢不了对手男足是‘谁也赢不了’我们赢不了对手。”这展示了同一个表达可以有不同的解释。
同样地在C中函数也可以重载。
5.1 函数重载概念
函数重载是指在同一作用域中声明几个功能类似但参数不同的同名函数。这些同名函数的参数列表参数个数、类型或类型顺序不同。函数重载常用于处理实现功能类似但数据类型不同的问题。
例子
#include iostream// 函数重载示例
void Print(int i) {std::cout 整数: i std::endl;
}void Print(double d) {std::cout 双精度: d std::endl;
}void Print(const std::string s) {std::cout 字符串: s std::endl;
}int main() {Print(42); // 调用 Print(int)Print(3.14); // 调用 Print(double)Print(Hello!); // 调用 Print(const std::string)return 0;
}5.2 C支持函数重载的原理 -- 名字修饰 (Name Mangling)
为什么C支持函数重载而C语言不支持呢这是因为C使用了一种叫做名字修饰Name Mangling的技术。
在C/C中一个程序要运行需要经历以下几个阶段预处理、编译、汇编、链接。 实际项目通常由多个头文件和多个源文件构成。编译链接阶段如果在 a.cpp 中调用了 b.cpp 中定义的 Add 函数编译后链接前a.o 的目标文件中没有 Add 的函数地址因为 Add 定义在 b.cpp 中。所以链接阶段链接器会到 b.o 的符号表中找到 Add 的地址然后将它们链接到一起。 链接时面对 Add 函数链接器会使用函数名修饰规则来找到函数。不同编译器有不同的函数名修饰规则。 由于 Windows 下 VS 的修饰规则过于复杂而 Linux 下 G 的修饰规则简单易懂我们使用 G 演示修饰后的名字。 在 G 中函数名修饰后的名字是 _Z 函数长度 函数名 类型首字母。
例子
采用C语言编译器编译后
// test.c
int Add(int a, int b) {return a b;
}编译后函数名未发生改变
$ gcc -c test.c
$ nm test.o
0000000000000000 T Add采用C编译器编译后
// test.cpp
int Add(int a, int b) {return a b;
}编译后函数名发生改变
$ g -c test.cpp
$ nm test.o
0000000000000000 T _Z3Addii通过名字修饰C 可以区分同名函数只要参数不同修饰后的名字就不一样支持函数重载。而C语言无法支持重载因为同名函数无法区分。
结论
C语言不支持函数重载因为同名函数无法区分。C支持函数重载通过名字修饰技术将参数类型信息添加到函数名中使得同名函数可以区分。两个函数如果函数名和参数都相同即使返回值不同也不构成重载因为编译器无法区分它们。
6. 引用
6.1 引用概念
引用是C中一个重要的概念它并不是定义一个新变量而是给已经存在的变量取了一个别名。引用和被引用的变量共享同一块内存空间因此引用不会占用额外的内存空间。
语法
类型 引用变量名 实体变量;例子
int a 10;
int ref a; // ref 是 a 的引用这里 ref 是 a 的别名通过 ref 可以操作 a。
注意 引用类型必须和引用实体是同种类型。
6.2 引用特性 1.引用在定义时必须初始化 int a 10;
int ref a; // 必须初始化2.一个变量可以有多个引用 int a 10;
int ref1 a;
int ref2 a; // a 有多个引用3.引用一旦引用一个实体再不能引用其他实体 int a 10;
int b 20;
int ref a;
// ref b; // 错误ref 不能再引用 b只能修改 a 的值
ref b; // 这只是把 b 的值赋给 a而不是让 ref 引用 b6.3 常引用 常引用const reference指向一个不能修改的变量这样可以防止通过引用修改变量的值。 例子 int a 10;
const int ref a; // ref 是常引用不能通过 ref 修改 a 的值
// ref 20; // 错误不能修改6.4 使用场景
1.做参数
void printValue(const int value) {std::cout value std::endl;
}int main() {int a 10;printValue(a); // 传递引用return 0;
}2.做返回值 int getElement(int arr[], int index) {return arr[index];
}int main() {int arr[3] {1, 2, 3};getElement(arr, 1) 10; // 修改 arr[1] 的值std::cout arr[1] std::endl; // 输出 10return 0;
}注意 如果函数返回时返回的对象还在作用域内没有被销毁则可以使用引用返回否则必须使用传值返回。 6.5 传值、传引用效率比较
传值时函数会传递实参的一份拷贝这在处理大数据时效率低。传引用则直接操作实参提高效率。
例子
void printByValue(std::string s) {std::cout s std::endl;
}void printByReference(const std::string s) {std::cout s std::endl;
}int main() {std::string str Hello, World!;printByValue(str); // 传值效率低printByReference(str); // 传引用效率高return 0;
}6.6 引用和指针的区别
引用是变量的别名指针存储变量的地址 int a 10;
int ref a; // 引用
int* ptr a; // 指针引用在定义时必须初始化指针可以不初始化 int a 10;
int ref a; // 必须初始化
int* ptr; // 可以不初始化
ptr a; // 之后再初始化引用一旦初始化后不能再改变引用对象指针可以随时指向其他对象 int a 10;
int b 20;
int ref a;
// ref b; // 错误引用不能改变对象
int* ptr a;
ptr b; // 可以改变指向没有NULL引用但有NULL指针 int* ptr nullptr; // NULL指针
// int ref nullptr; // 错误没有NULL引用sizeof引用和指针 int a 10;
int ref a;
int* ptr a;
std::cout sizeof(ref) std::endl; // 输出变量类型的大小
std::cout sizeof(ptr) std::endl; // 输出指针类型的大小4或8字节引用自加即引用的实体增加1指针自加即指针向后偏移一个类型的大小 int a 10;
int ref a;
ref; // a 的值变为 11int arr[3] {1, 2, 3};
int* ptr arr;
ptr; // ptr 指向下一个元素有多级指针但没有多级引用 int a 10;
int* ptr a;
int** pptr ptr; // 多级指针
// int ref a; // 没有多级引用访问实体方式不同 int a 10;
int ref a;
int* ptr a;ref 20; // 直接使用引用
*ptr 20; // 显式解引用引用比指针使用起来更安全
引用在初始化后不能变更使得引用在使用上比指针更安全。 7. 内联函数
7.1 概念
内联函数是使用 inline 关键字修饰的函数。在编译时C编译器会在调用内联函数的地方直接展开函数体而不是进行正常的函数调用。这避免了函数调用时建立栈帧的开销从而提升程序运行的效率。
例子
#include iostream// 定义内联函数
inline int Add(int a, int b) {return a b;
}int main() {int result Add(3, 4); // 调用内联函数std::cout 结果: result std::endl;return 0;
}7.2 特性 以空间换时间 概念内联函数用函数体替换函数调用省去调用的开销但会使目标文件变大。缺点目标文件变大因为每次调用内联函数都会复制函数体。优点减少函数调用的开销提高运行效率。 编译器建议 例子 inline void SmallFunction() {// 函数体很小适合内联
}3.声明和定义不分离 概念inline 对编译器来说只是建议不同编译器对 inline 的实现机制不同。建议使用场景将小规模、非递归、且频繁调用的函数使用 inline 修饰。长函数或递归函数不适合使用 inline编译器可能会忽略 inline。
概念内联函数不建议将声明和定义分离否则可能导致链接错误。
原因内联函数在编译阶段展开不会生成函数地址链接阶段找不到函数地址会报错。
错误例子
// header.h
inline int Add(int a, int b); // 声明// source.cpp
inline int Add(int a, int b) { // 定义return a b;
}// main.cpp
#include header.h
int main() {Add(3, 4);return 0;
}正确例子
// header.h
inline int Add(int a, int b) {return a b;
}// main.cpp
#include header.h
int main() {Add(3, 4);return 0;
}7.3 内联函数的使用建议
内联函数适合用在短小且频繁调用的函数上可以减少函数调用的开销。不适合将大函数和递归函数设为内联因为这会增加代码体积并可能导致编译器忽略 inline 关键字。内联函数通常在头文件中定义因为内联函数在编译阶段展开需要在每个调用的地方都能看到函数体。
8. auto 关键字
8.1 类型别名思考
随着程序的复杂度增加程序中用到的类型也变得越来越复杂导致以下问题
类型难于拼写例如std::mapstd::string, std::string::iterator 是一个非常长的类型名很容易写错。含义不明确导致容易出错复杂的类型名可能会导致理解上的混淆。
聪明的程序员想到可以使用 typedef 给类型取别名例如
typedef std::mapstd::string, std::string::iterator MapIterator;虽然 typedef 可以简化代码但它也有一些缺点尤其是当我们需要根据表达式的类型来声明变量时可能并不容易知道表达式的类型。
8.2 auto 简介
在早期的 C/C 中auto 表示局部变量的自动存储类型但几乎没人使用它。
在 C11 中auto 被赋予了新的含义它不再是存储类型指示符而是类型指示符。使用 auto 声明的变量由编译器在编译期推导其实际类型。
注意 使用 auto 定义变量时必须对其进行初始化以便编译器推导其实际类型。
例子
#include iostream
#include map
#include stringint main() {std::mapstd::string, std::string myMap;myMap[hello] world;// 使用 auto 简化代码auto it myMap.begin();std::cout it-first : it-second std::endl;return 0;
}8.3 auto 的使用细则
1.auto 与指针和引用结合使用
用 auto 声明指针类型时用 auto 和 auto* 没有区别但用 auto 声明引用类型时必须加 。
int a 10;
auto ptr a; // ptr 是 int*
auto ref a; // ref 是 intstd::cout *ptr , ref std::endl;2.在同一行定义多个变量
当在同一行声明多个变量时这些变量必须是相同的类型否则编译器将报错因为编译器只对第一个变量进行类型推导。
auto x 10, y 20; // 正确x 和 y 都是 int
// auto a 10, b 3.14; // 错误a 是 intb 是 double类型不同8.4 auto 不能推导的场景
1.auto 不能作为函数的参数
// void func(auto x); // 错误不能使用 auto 作为函数参数2.auto 不能直接用来声明数组
// auto arr[10]; // 错误不能直接用 auto 声明数组3.为了避免与 C98 中的 auto 混淆C11 只保留了 auto 作为类型指示符的用法
4.auto 最常见的优势用法是与 C11 提供的新式 for 循环和 lambda 表达式配合使用
std::vectorint vec {1, 2, 3, 4, 5};// 使用 auto 与新式 for 循环
for (auto val : vec) {std::cout val ;
}
std::cout std::endl;9. 基于范围的 for 循环
9.1 范围 for 的语法
在 C98 中如果要遍历一个数组可以按照以下方式进行
int arr[] {1, 2, 3, 4, 5};
for (int i 0; i 5; i) {std::cout arr[i] std::endl;
}C11 引入了基于范围的 for 循环使得遍历更加简单。for 循环后的括号由冒号 : 分为两部分第一部分是范围内用于迭代的变量第二部分则表示被迭代的范围。
例子
#include iostream
#include vectorint main() {std::vectorint vec {1, 2, 3, 4, 5};// 基于范围的 for 循环for (const auto val : vec) {std::cout val ;}std::cout std::endl;return 0;
}注意 可以用 continue 结束本次循环用 break 跳出整个循环。
9.2 范围 for 的使用条件 循环迭代的范围必须是确定的 对于数组而言就是数组中第一个元素和最后一个元素的范围对于类而言应该提供 begin 和 end 的方法。 迭代的对象要实现 和 的操作
10. 指针空值 nullptr
10.1 C98 中的指针空值
在 C/C 中如果一个指针没有合法的指向我们通常会将其初始化为 NULL。
int* p NULL; // 或者 int* p 0;但是 NULL 实际上是一个宏定义通常被定义为 0 或 (void*)0这可能导致一些问题。
例子
void f(int);
void f(int*);f(NULL); // 编译器可能会选择 f(int) 而不是 f(int*)10.2 nullptr 简介
C11 引入了新的关键字 nullptr专门表示空指针值以解决 NULL 的问题。
例子
10.2 nullptr 简介
C11 引入了新的关键字 nullptr专门表示空指针值以解决 NULL 的问题。例子
注意
使用 nullptr 表示指针空值时不需要包含头文件因为 nullptr 是 C11 引入的关键字。在 C11 中sizeof(nullptr) 与 sizeof((void*)0) 所占的字节数相同。为了提高代码的健壮性建议在表示指针空值时使用 nullptr。
