网站内容一样影响收录,iis装网站,ps快速做网站,公共资源交易中心事业编怎么样C11
decltype类型推导 decltype不依赖于初始化#xff0c;根据表达式类推导类型 auto b #xff1a;根据右边a的初始值来推导出变量的类型#xff0c;然后将该初始值赋给bdecltype 则是根据a表达式来推导类型#xff0c;变量的初始值与表达式的值无关表达式类型注意点11
decltype类型推导 decltype不依赖于初始化根据表达式类推导类型 auto b 根据右边a的初始值来推导出变量的类型然后将该初始值赋给bdecltype 则是根据a表达式来推导类型变量的初始值与表达式的值无关表达式类型注意点如果表达式是左值则推导出的类型也是左值引用 int a 10;
auto b a;
decltype(a) b a; // b的类型是intint add(int a, int b) {return a b;
}decltype(add(1, 2)) result; // result的类型是intint x 5;
int ref x;
decltype(ref) newRef x; // newRef的类型是intint func(int a, int b) {return a b;
}decltype(func) funcPtr func; // funcPtr的类型是int (*)(int, int)bind 基本语法 callable可以是函数指针、成员函数指针、函数对象或 lambda 表达式。arg1, arg2, ..., argN指定参数可以是具体的值也可以是占位符例如 std::placeholders::_1占位符 在使用 std::bind 时可以使用占位符来表示绑定函数的参数位置。占位符定义在 std::placeholders 命名空间中通常用 _1、_2 等表示。例如 std::placeholders::_1 表示绑定函数的第一个参数。std::placeholders::_2 表示绑定函数的第二个参数注意 参数绑定顺序std::bind 会按照传递给它的参数顺序进行绑定。占位符的编号必须与实际参数的位置相对应。捕获外部变量使用 std::bind 时可以将外部变量作为绑定参数传递从而实现闭包效果。返回类型推导std::bind 创建的函数对象会自动推导返回类型无需显式指定 绑定成员函数常用 #include iostream
#include functionalclass MyClass {
public:void print_message(const std::string message) {std::cout Message: message std::endl;}
};int main() {MyClass my_object;// 绑定成员函数auto bound_member_function std::bind(MyClass::print_message, my_object, std::placeholders::_1);bound_member_function(Hello, World!); // 输出Message: Hello, World!return 0;
}绑定函数 #include iostream
#include functionalvoid print_sum(int a, int b) {std::cout Sum: a b std::endl;
}int main() {// 绑定参数到具体值auto bound_print std::bind(print_sum, 5, 3);bound_print(); // 输出Sum: 8// 使用占位符auto bound_print_with_placeholder std::bind(print_sum, std::placeholders::_1, 10);bound_print_with_placeholder(5); // 输出Sum: 15return 0;
}绑定函数对象 #include iostream
#include functionalstruct Multiply {int operator()(int a, int b) const {return a * b;}
};int main() {Multiply multiply;// 绑定函数对象auto bound_multiply std::bind(multiply, std::placeholders::_1, 4);std::cout Product: bound_multiply(5) std::endl; // 输出Product: 20return 0;
}范围for 作用遍历容器中的数据参数 declaration用于声明每次迭代中从容器中提取的元素可以是变量或引用。expression表示需要遍历的容器或范围注意点 自动推导类型可以使用auto关键字自动推导元素类型如果不需要修改容器中的元素最后使用const声明元素避免容器中的数据被修改范围任何可以使用begin 和 end 的容器 事例代码 #include iostream
#include vectorint main() {std::vectorint vec {1, 2, 3, 4, 5};// 使用引用遍历并修改元素for (int elem : vec) {elem * 2;}for (int elem : vec) {std::cout elem ;}std::cout std::endl;return 0;
}右值引用 左值与右值 左值持久存储的对象通常是变量右值没有持久存储的临时对象一般都是临时变量 用法move可以显式的将一个左值转换为对应的右值引用类型 右值引用与移动语义结合事例代码 #include iostream
#include vector
#include stringclass Resource {
public:std::string name;std::vectorint data;Resource(const std::string name) : name(name) {std::cout Constructing name std::endl;}Resource(const Resource other) : name(other.name), data(other.data) {std::cout Copy Constructing name std::endl;}Resource(Resource other) noexcept : name(std::move(other.name)), data(std::move(other.data)) {std::cout Move Constructing name std::endl;}Resource operator(Resource other) noexcept {if (this ! other) {name std::move(other.name);data std::move(other.data);std::cout Move Assigning name std::endl;}return *this;}
};int main() {Resource res1(Resource1);Resource res2(Resource2);// 触发移动构造函数Resource res3 std::move(res1);// 触发移动赋值运算符res2 std::move(res3);return 0;
}标准库move函数 用法总结 作用将参数显式的转换为一个右值引用使对象可以通过移动而不是复制的方式传递或者返回从而提高程序性能例如在动态内存等场景中让资源空间移动可以避免复制开辟空间的性能消耗理解提供一个移动资源的方法实现将其参数转换为右值引用 使用代码事例 #include iostream
#include vector
#include utility // for std::moveint main() {std::vectorint v1 { 1, 2, 3, 4, 5 };std::vectorint v2;// 使用 std::move 将 v1 转换为右值引用从而启用移动语义v2 std::move(v1);// 现在 v1 应该是空的v2 持有原先 v1 的资源std::cout v1 size: v1.size() std::endl;std::cout v2 size: v2.size() std::endl;return 0;
} 如果想要对象支持移动语义则需要的为其定义移动构造函数以及移动赋值运算符 class MyClass {
public:MyClass() : data(new int[100]) {}~MyClass() { delete[] data; }// 移动构造函数MyClass(MyClass other) noexcept : data(other.data) {other.data nullptr;}// 移动赋值运算符MyClass operator(MyClass other) noexcept {if (this ! other) {delete[] data;data other.data;other.data nullptr;}return *this;}// 禁用复制构造函数和复制赋值运算符MyClass(const MyClass) delete;MyClass operator(const MyClass) delete;private:int* data;
};禁用对象默认函数
C11中如果不希望对象被复制可以将复制构造函数以及复制赋值函数声明为delete来禁用移动构造和移动赋值同样适用。C11之前可以将对象的默认函数放入私有域中从而达到禁止使用默认函数的功能。 代码事例C11中的做法以及private禁止默认函数的做法 class MyClass {
public:MyClass() default;~MyClass() default;// 禁用复制构造函数MyClass(const MyClass) delete;// 禁用复制赋值运算符MyClass operator(const MyClass) delete;// 禁用移动构造函数MyClass(MyClass) delete;// 禁用移动赋值运算符MyClass operator(MyClass) delete;
};class MyClass {
public:MyClass() {}~MyClass() {}private:// 禁用复制构造函数MyClass(const MyClass);// 禁用复制赋值运算符MyClass operator(const MyClass);// 禁用移动构造函数MyClass(MyClass);// 禁用移动赋值运算符MyClass operator(MyClass);
};
constexpr
该关键字用于指示表达式或者函数在编译的时候求职用于定义常量表达式从而提高程序的效率和安全性。 constexpr变量 编译时求值的常量constexpr确保在编译时进行求值而const只可以确保值不能在运行中改变 constexpr int square(int x) {return x * x;
}int main() {constexpr int a 10;constexpr int b square(a); // 在编译时求值int arr[b]; // 使用编译时常量作为数组大小return 0;
}constexpr函数 该函数是在编译时求值使用条件 函数的返回类型以及参数必须是字面值类型函数体中只可以包含单一的return语句注意该规定在C14中更改了 constexpr int factorial(int n) {return (n 1) ? 1 : (n * factorial(n - 1));
}int main() {constexpr int result factorial(5); // 在编译时计算 5 的阶乘static_assert(result 120, Factorial calculation is incorrect);return 0;
}constexpr 与 const的区别 const确保变量在运行的时候是只读的但不一定在编译的时候求值constexpr确保表达式在编译时求值并且变量在运行的时候是只读 const int a 10; // 运行时常量
constexpr int b 10; // 编译时常量const int x factorial(a); // 可以在运行时计算
constexpr int y factorial(b); // 必须在编译时计算初始化列表 initializer list 用法总结 语法使用直接初始化成员变量而不用在构造函数体内赋值特点 优化性能减少性能开销const成员变量必须通过初始化列表进行初始化因为const成员变量在构造完成后不可以被赋值引用成员也必须通过初始化列表进行初始化顺序列表中的初始化的顺序必须和类中声明顺序一致 class MyClass {
public:MyClass(int a, int b) : x(a), y(b), z(a b), ref(a) {}
private:const int x;int y;int z;int ref;
};nullptr 用法总结 作用C11之前使用NULL宏来表示NULL宏被定义为整数0容易在上下文中引起歧义nullptr则是一个指针字面值专门用于表示空指针不存在歧义问题优点 类型安全nullptr是一个指针类型所以不会与整数类型混淆函数重载的时候nullptr可以帮忙区分指针和整数参数 C14
函数返回值类型推导 作用允许编译器根据函数返回语句自动推导出返回类型下面案例是自动推导出int类型注意 单一返回类型函数中所有返回语句必须是相同类型否则编译器会报错返回引用和指针的时候需要确保返回的对象在作用域中是否有效避免悬空引用 #include iostreamauto add(int a, int b) {return a b;
}int main() {std::cout add(2, 3) std::endl; // 输出 5return 0;
}lambda函数形参允许泛型 作用无需预先指定参数类型编译器根据lambda的使用情况自动推导参数的类型 事例案例理解 #include iostreamint main() {auto add [](auto x, auto y) {return x y;};std::cout add(1, 2) std::endl; // 输出 3std::cout add(1.5, 2.5) std::endl; // 输出 4.0std::cout add(std::string(Hello, ), std::string(World!)) std::endl; // 输出 Hello, World!return 0;
}#include iostream
#include vector
#include algorithmint main() {int factor 2;auto multiply [factor](auto x) {return x * factor;};std::cout multiply(3) std::endl; // 输出 6std::cout multiply(3.5) std::endl; // 输出 7.0return 0;
}
#include iostream
#include vector
#include algorithmint main() {std::vectorint vec {1, 2, 3, 4, 5};auto print [](const auto container) {for (const auto elem : container) {std::cout elem ;}std::cout std::endl;};print(vec); // 输出 1 2 3 4 5return 0;
}变量模板 作用类似于函数模板但是是给变量使用的一种模板 #include iostreamtemplatetypename T
constexpr T pi T(3.1415926535897932385);int main() {std::cout pifloat std::endl; // 输出 3.14159std::cout pidouble std::endl; // 输出 3.141592653589793std::cout pilong double std::endl; // 输出 3.1415926535897932385return 0;
} 常量模版事例中是获取不同类型的最大值 #include iostreamtemplatetypename T
constexpr T max_value std::numeric_limitsT::max();int main() {std::cout max_valueint std::endl; // 输出 int 类型的最大值std::cout max_valueunsigned int std::endl; // 输出 unsigned int 类型的最大值std::cout max_valuedouble std::endl; // 输出 double 类型的最大值return 0;
} 属性模版下面事例展示用于计算的给定类型的平方根 #include iostream
#include cmathtemplatetypename T
constexpr T square(T x) {return x * x;
}templatetypename T
constexpr T sqrt_value std::sqrt(square(T(2)));int main() {std::cout sqrt_valuefloat std::endl; // 输出 2.82843std::cout sqrt_valuedouble std::endl; // 输出 2.82843std::cout sqrt_valuelong double std::endl; // 输出 2.82843return 0;
} 类模版和变量模板 #include iostreamtemplatetypename T
struct Traits {static constexpr T zero T(0);
};int main() {std::cout Traitsint::zero std::endl; // 输出 0std::cout Traitsfloat::zero std::endl; // 输出 0std::cout Traitsdouble::zero std::endl; // 输出 0return 0;
} deprecated属性 作用标记不建议使用的函数、变量或者类型如果使用了则编译的时候会报错 标记函数被弃用 #include iostream[[deprecated]]
void oldFunction() {std::cout This is an old function. std::endl;
}void newFunction() {std::cout This is a new function. std::endl;
}int main() {oldFunction(); // 编译时会产生警告newFunction(); // 正常调用return 0;
} 标记变量弃用 #include iostream[[deprecated(Use newVar instead)]]
int oldVar;int newVar;int main() {oldVar 10; // 编译时会产生警告newVar 20; // 正常使用std::cout oldVar std::endl;std::cout newVar std::endl;return 0;
}标记类型弃用 #include iostream[[deprecated(Use NewStruct instead)]]
struct OldStruct {int value;
};struct NewStruct {int value;
};int main() {OldStruct oldInstance; // 编译时会产生警告oldInstance.value 10;NewStruct newInstance;newInstance.value 20;std::cout oldInstance.value std::endl;std::cout newInstance.value std::endl;return 0;
}标记类的成员函数被弃用 #include iostreamclass MyClass {
public:[[deprecated(Use newMethod() instead)]]void oldMethod() {std::cout This is the old method. std::endl;}void newMethod() {std::cout This is the new method. std::endl;}
};int main() {MyClass obj;obj.oldMethod(); // 编译时会产生警告obj.newMethod(); // 正常调用return 0;
} std::make_unique 作用用于创建std::unique_ptr对象以一种更安全高效的方式创建智能指针避免new的内存泄漏风险优点 避免内存泄漏类型安全会自动推导出指针类型减少类型错误的风险语法分析 T 是要创建的对象的类型。Args... args 是传递给 T 的构造函数的参数 创建一个对象创建一个指向整数42的unique_ptr #include iostream
#include memoryint main() {auto p std::make_uniqueint(42);std::cout *p std::endl; // 输出 42return 0;
} 创建动态数组 #include iostream
#include memoryint main() {auto p std::make_uniqueint[](5);for (int i 0; i 5; i) {p[i] i * i;}for (int i 0; i 5; i) {std::cout p[i] ; // 输出 0 1 4 9 16}std::cout std::endl;return 0;
} 创建自定义对象 #include iostream
#include memoryclass MyClass {
public:MyClass(int x) : x_(x) {std::cout MyClass constructed with x_ std::endl;}~MyClass() {std::cout MyClass destructed std::endl;}int getX() const { return x_; }private:int x_;
};int main() {auto p std::make_uniqueMyClass(10);std::cout p-getX() std::endl; // 输出 10return 0;
} C17
结构化绑定 作用通过简单的语法实现将变量绑定到结构或者元祖的成员上 解构元组 #include iostream
#include tuplestd::tupleint, double, std::string getTuple() {return {1, 2.5, hello};
}int main() {auto [x, y, z] getTuple();std::cout x: x , y: y , z: z std::endl;return 0;
} 解构结构体 #include iostreamstruct Point {int x;int y;
};int main() {Point p{10, 20};auto [x, y] p;std::cout x: x , y: y std::endl;return 0;
} 解构数组 #include iostreamint main() {int arr[] {1, 2, 3};auto [a, b, c] arr;std::cout a: a , b: b , c: c std::endl;return 0;
}与标准库结合使用 #include iostream
#include mapint main() {std::mapint, std::string m {{1, one}, {2, two}, {3, three}};for (const auto [key, value] : m) {std::cout key: key , value: value std::endl;}return 0;
} if-switch语句初始化 含义允许在if 和switch语句中进行初始化从而让变量的作用域更加局部化根据具体事例理解 if语句初始化auto it ...初始化只在if语句范围内有用 #include iostream
#include vectorint main() {std::vectorint vec {1, 2, 3, 4, 5};if (auto it std::find(vec.begin, vec.end(), 3); it ! vec.end()) {std::cout Found 3 at index std::distance(vec.begin(), it) std::endl;} else {std::cout 3 not found std::endl;}return 0;
}Switch语句初始化也同样只在Switch语句范围内起作用 #include iostream
#include mapenum class Color { RED, GREEN, BLUE };int main() {std::mapstd::string, Color colorMap {{red, Color::RED}, {green, Color::GREEN}, {blue, Color::BLUE}};std::string colorStr green;switch (auto it colorMap.find(colorStr); it ! colorMap.end() ? it-second : Color::BLUE) {case Color::RED:std::cout Color is red std::endl;break;case Color::GREEN:std::cout Color is green std::endl;break;case Color::BLUE:std::cout Color is blue std::endl;break;default:std::cout Unknown color std::endl;break;}return 0;
}constexpr lambda表达式 总结 该lambda表达式可以在编译的时候进行常量计算从而提高代码效率和安全性。注意 表达式限制 constexpr lambda表达式中的代码必须符合constexpr函数的要求常量上下文该lambda表达式必须能够在编译的时候计算 #include iostreamconstexpr auto add [](int a, int b) constexpr {return a b;
};int main() {constexpr int result add(3, 4); // 在编译时计算std::cout Result: result std::endl; // 输出 7return 0;
} 常量计算 #include iostream
#include arrayconstexpr auto square [](int x) constexpr {return x * x;
};int main() {constexpr int value 5;constexpr int result square(value); // 在编译时计算std::arrayint, result arr; // 使用计算结果作为数组大小std::cout Array size: arr.size() std::endl; // 输出 25return 0;
} 与标准库结合使用的场景 #include iostream
#include algorithm
#include arrayint main() {constexpr auto greater [](int a, int b) constexpr {return a b;};std::arrayint, 5 arr {5, 2, 3, 4, 1};std::sort(arr.begin(), arr.end(), greater); // 在运行时排序for (const auto elem : arr) {std::cout elem ; // 输出 5 4 3 2 1}std::cout std::endl;return 0;
}namespace嵌套 基于语法结构 #include iostreamnamespace Outer {int outerVar 10;namespace Inner {int innerVar 20;class InnerClass {public:void display() {std::cout Outer variable: outerVar std::endl;std::cout Inner variable: innerVar std::endl;}};}
}int main() {Outer::Inner::InnerClass obj;obj.display();return 0;
} #include iostreamnamespace Outer {int outerVar 10;namespace Inner {int innerVar 20;class InnerClass {public:void display() {std::cout Outer variable: outerVar std::endl;std::cout Inner variable: innerVar std::endl;}};}
}int main() {Outer::Inner::InnerClass obj;obj.display();return 0;
}std::any 总结 含义提供一种类型安全的方式来存储和操作任意类型的值可以理解成动态语言中的万能类型使用场景用来代替一些需要存储不同类型对象的场景事例代码 定义和使用any类型定义的数值访问存储的数值检查any中的类型type() #include iostream
#include anyint main() {std::any a 1; // 存储 int 类型std::cout std::any_castint(a) std::endl;a 3.14; // 存储 double 类型std::cout std::any_castdouble(a) std::endl;a std::string(Hello, std::any!); // 存储 std::string 类型std::cout std::any_caststd::string(a) std::endl;return 0;
}#include iostream
#include anyint main() {std::any a 10;try {int value std::any_castint(a);std::cout Value: value std::endl;} catch (const std::bad_any_cast e) {std::cout Bad any_cast: e.what() std::endl;}return 0;
}#include iostream
#include any
#include typeinfoint main() {std::any a 10;if (a.type() typeid(int)) {std::cout a contains an int std::endl;} else {std::cout a does not contain an int std::endl;}return 0;
}std::basic_string_view 总结 作用轻量级、非拥有的字符串视图类型对字符串只读访问也就是只查看字符串指定内容不需要复制或者拥有字符串的实际数据特点 轻量级只是一个视图不拥有数据所以构造和赋值的性能开销小无拷贝因为不需要数据所以不会进行数据拷贝灵活可以按照自己的需要灵活拷贝字符串 #include iostream
#include string_viewvoid printString(std::string_view sv) {std::cout sv std::endl;
}int main() {std::string str Hello, std::string_view!;printString(str); // 传递 std::stringprintString(Hello, world!); // 传递字符串字面量printString(str.substr(7, 12)); // 传递 std::string 的子字符串return 0;
}//基本操作#include iostream
#include string_viewint main() {std::string_view sv Hello, world!;std::cout Length: sv.length() std::endl; // 输出长度std::cout First character: sv.front() std::endl; // 输出第一个字符std::cout Last character: sv.back() std::endl; // 输出最后一个字符std::cout Substring: sv.substr(7, 5) std::endl; // 输出子字符串 world// 查找子字符串size_t pos sv.find(world);if (pos ! std::string_view::npos) {std::cout \world\ found at position pos std::endl;}return 0;
}#include iostream
#include string_viewint main() {std::string_view sv Hello, world!;std::cout Length: sv.length() std::endl; // 输出长度std::cout First character: sv.front() std::endl; // 输出第一个字符std::cout Last character: sv.back() std::endl; // 输出最后一个字符std::cout Substring: sv.substr(7, 5) std::endl; // 输出子字符串 world// 查找子字符串size_t pos sv.find(world);if (pos ! std::string_view::npos) {std::cout \world\ found at position pos std::endl;}return 0;
}C和C 相同点 基本语法结构循环控制函数定义都类似基本数据结构C中的标准库函数在C中同样适用指针与数组使用方法类似预处理指令 不同点 面向对象C支持面向对象函数与运算符重载C支持C不支持模板C支持C支持STL标准库两者的内存管理不同C有异常处理机制但是C没有 Java和C 相同点 面向对象编程 两者都支持面向对象编程包括类、继承、多态、封装等概念。 语法结构 两者的基本语法结构相似如 if-else、for 循环、while 循环、switch 语句等 基本数据类型 都有基本数据类型如 int、char、float、double 等。 标准库支持 两者都提供了丰富的标准库用于字符串操作、输入输出、集合等 不同点 内存管理 C 需要手动进行内存管理使用 new 和 delete 进行动态内存分配和释放。Java 有垃圾回收机制自动管理内存。 平台独立性 C 编译生成的可执行文件是平台相关的。Java 编译生成字节码运行在 Java 虚拟机JVM上实现平台独立性。 多重继承 C 支持多重继承。Java 不支持多重继承但可以通过接口实现类似效果。 指针 C 直接支持指针。Java 不直接支持指针提供了引用类型。 异常处理 Java 强制使用异常处理许多库函数都会抛出异常。C 提供异常处理机制但使用不如 Java 强制。 模板与泛型 C 使用模板实现泛型编程。Java 使用泛型但类型信息在运行时会被擦除类型擦除 Python和C 相同点 支持面向对象编程 两者都支持面向对象编程。 丰富的标准库 两者都提供了丰富的标准库支持多种功能 不同点 语法和易用性 Python 语法简单易读强调代码的可读性。C 语法复杂更加灵活但也更容易出现错误。 性能 C 是编译型语言性能高适合对性能要求高的系统编程。Python 是解释型语言性能较低但开发速度快适合快速开发和脚本编写。 内存管理 C 手动管理内存。Python 有自动垃圾回收机制。 类型系统 C 是静态类型语言编译时检查类型。Python 是动态类型语言运行时检查类型。 并发与并行 C 提供了多线程和多进程的并发机制。Python 也支持多线程和多进程但由于全局解释器锁GIL的存在多线程性能受限多进程更常用。 应用领域 C 常用于系统编程、游戏开发、嵌入式系统等。Python 常用于数据分析、机器学习、Web 开发、自动化脚本等 Go和C 相同点 编译型语言源代码在执行前需要编译成可执行文件编译时对类型进行检查支持标准库比如文件操作或者网络编程等 不同点 语法 Go语法简洁代码可读性高C语法复杂功能强大但是容易导致代码冗长难以维护内存管理 Go有垃圾回收机制自动管理内存C需要手动管理内存并发编程 Go内置强大的并发支持可以通过goroutines和channels实现并发C的多线程编程较为麻烦编译时间 Go变异速度快适合快速开发和部署C编译速度慢 错误处理 Go 使用显式错误处理通过返回值和 error 类型处理错误。C 使用异常处理机制通过 try-catch 块捕获和处理异常。 面向对象编程 C 是面向对象语言支持类、继承、多态等特性。Go 支持面向对象编程但没有类和继承使用结构体和接口实现类似功能 Rust和C 相同点 编译型语言代码执行前都需要编译成可执行文件强类型检查编译的时候都会进行类型检查都对底层硬件和内存进行精细控制适合系统编程和高性能应用 不同点 内存管理 C需要程序员管理内存通常需要使用new和delete进行动态内存分配和释放Rust则使用所有权系统和借助检查器管理内存编译的时候保证内存安全无需垃圾回收并发编程 Rust提供了安全的并发编程通过所有权和类型系统在编译的时候防止数据竞争C支持多线程编程但是需要使用更复杂的线程库和同步机制 错误处理 Rust使用显式错误处理通过Result和Option类型来处理错误C使用异常处理机制通过try-catch模块来捕捉异常面向对象 C支持面向对象语言支持类、继承、多态等Rust则不支持传统的面向对象编程但是提供结构体和特征来实现类似功能
