C++11 01-Automatic type deduction 自动类型推导

于 2024-10-12 07:00:00 发布
阅读量680 收藏 11
点赞数 19
分类专栏： C++ 文章标签： c++ 开发语言 C++11
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wesigj/article/details/142745210
版权

系列文章目录

点击直达——文章总目录

文章目录

C++11 1-Automatic type deduction 自动类型推导

Overview

1.Automatic type deduction 自动类型推导

C++11 引入了 auto 关键字，用于自动类型推导，它让编译器自动推断变量的类型。这不仅可以简化代码，还可以提高代码的可读性和可维护性。

1.1.自动类型推导的工作原理

auto 关键字告诉编译器，变量的类型应该从初始化表达式中推断出来。编译器分析变量的初始化值，并确定最合适的类型。

1.2.实际例子

以下是一些使用 auto 关键字的实际例子：

1.2.1. 基本用法
#include <iostream>
#include <vector>

int main() {
    // auto 用于自动推断变量类型
    auto x = 5;
    std::cout << "x is of type: " << typeid(x).name() << " and value is " << x << std::endl;

    auto y = 3.14;
    std::cout << "y is of type: " << typeid(y).name() << " and value is " << y << std::endl;

    auto z = "Hello, C++11";
    std::cout << "z is of type: " << typeid(z).name() << " and value is " << z << std::endl;

    return 0;
}
1.2.2. 用于容器
#include <iostream>
#include <vector>

int main() {
    // auto 用于自动推断容器元素的类型
    std::vector<int> v = {1, 2, 3, 4, 5};
    for (auto it = v.begin(); it != v.end(); ++it) {
        std::cout << *it << " ";
    }
    std::cout << std::endl;

    return 0;
}
1.2.3. 用于函数返回值
#include <iostream>
#include <string>

auto add(int a, int b) -> int {  // C++14 后也可以使用 auto 返回类型
    return a + b;
}

int main() {
    auto result = add(3, 5);
    std::cout << "Result is: " << result << std::endl;

    return 0;
}
1.2.4. 用于初始化列表
#include <iostream>
#include <vector>
#include <initializer_list>

int main() {
    // auto 用于自动推断初始化列表类型
    auto v = {1, 2, 3, 4, 5};
    for (auto num : v) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    return 0;
}
1.2.5. 用于复杂表达式
#include <iostream>
#include <utility>

int main() {
    int a = 5;
    int b = 10;
    // auto 用于自动推断复杂的表达式结果类型
    auto max = (a > b) ? a : b;
    std::cout << "Max is: " << max << std::endl;

    return 0;
}

1.3.注意事项

  1. auto 与函数返回类型：C++11 要求在变量声明时必须提供初始值，因此 auto 不能单独用于函数返回类型。但从 C++14 开始，可以使用 auto 声明函数返回类型。

  2. auto 与模板：在使用模板时，auto 可以帮助简化代码，特别是在处理复杂的模板实例化时。

  3. auto 与数组：auto 不能用于数组类型推导，因为数组的类型推导涉及到数组的大小。

通过这些例子，你可以看到 auto 关键字如何简化代码并提高可读性。在你的专栏文章中，可以进一步探讨 auto 的高级用法和最佳实践。

2.C++11 中的 auto 关键字在模板编程中有什么特别的应用吗？

在 C++11 中，auto 关键字被引入用于自动类型推导，这在模板编程中尤其有用。以下是 auto 在模板编程中的一些特别应用：

  1. 简化模板编程：在模板函数或模板类中，auto 可以用来简化复杂的类型声明。编译器可以根据模板实例化时的实际参数类型自动推导出相应的类型。

    template <typename T>
auto square(T x) -> decltype(x * x) {
    return x * x;
}

    在这个例子中，auto 结合 -> decltype(x * x) 语法，允许编译器自动推导出返回类型，这里返回类型将与 x 的类型相同。

  2. 自动推导迭代器类型：在模板容器类（如 std::vector）的迭代器中，auto 可以用来自动推导迭代器的类型。

    template <typename Container>
void printContainer(const Container& c) {
    for (auto it = c.begin(); it != c.end(); ++it) {
        std::cout << *it << " ";
    }
    std::cout << std::endl;
}

    这里，auto 允许编译器自动推导出迭代器的类型，无需程序员手动指定。

  3. 尾返回类型：C++11 允许在函数声明的末尾指定返回类型，这在模板编程中尤其有用，尤其是当返回类型依赖于模板参数时。

    template <typename T, typename U>
auto add(T x, U y) -> decltype(x + y) {
    return x + y;
}

    在这个例子中，返回类型是在函数声明的末尾指定的，编译器会根据 x + y 的结果自动推导出返回类型。

  4. 与 decltype 结合使用：auto 可以与 decltype 结合使用，以推导出复杂表达式的类型。

    template <typename T>
auto get(T& t) -> decltype(t.get()) {
    return t.get();
}

    在这个例子中，decltype(t.get()) 用于推导成员函数 get 的返回类型。

  5. 泛型 Lambda 表达式：C++14 扩展了 auto 的用法，允许在 Lambda 表达式中使用 auto 作为参数类型，这使得 Lambda 表达式可以更灵活地处理不同类型的参数。

    auto lambda = [](auto a, auto b) {
    return a + b;
};

    这里，Lambda 表达式可以接受任何类型的参数，并且会根据参数自动推导出操作。

  6. 类型擦除：在模板编程中，auto 可以用于实现类型擦除，即将具体类型替换为更通用的类型。

    template <typename T>
auto make_any(T&& arg) -> std::enable_if_t<std::is_convertible<T, std::any>::value, std::any> {
    return std::any(arg);
}

    在这个例子中，auto 用于创建一个可以存储任何类型的 std::any 对象。

使用 auto 可以提高代码的可读性和可维护性，同时减少因手动指定复杂类型时的错误。在模板编程中，auto 的这些应用可以大大简化代码，使其更加简洁和通用。

3.C++11 中的 auto 关键字在函数重载中有什么作用？

在 C++11 中，auto 关键字在函数重载中的作用主要体现在简化类型声明和提高代码的可读性。以下是一些具体的应用场景：

3.1. 返回类型推导

在函数重载的情况下，auto 可以用来推导返回类型，使得函数声明更加简洁。这在模板函数中尤其有用，因为模板函数可能需要处理不同类型的返回值。

auto add(int a, int b) -> int {
    return a + b;
}

auto add(double a, double b) -> double {
    return a + b;
}

auto add(int a, double b) -> double {
    return a + b;
}

在这个例子中，每个 add 函数的返回类型由参数类型决定，auto 结合尾置返回类型（trailing return type）简化了函数的声明。

3.2. 简化模板函数的重载

auto 结合模板可以简化重载函数的声明，尤其是在处理不同类型的参数和返回值时。

template <typename T>
auto transform(T t) -> T&& {
    // Do something with t and return it
    return std::move(t);
}

int i = 10;
auto j = transform(i); // int&, not int

std::string s = "hello";
auto t = transform(s); // std::string&&, not std::string

在这个例子中，transform 函数根据传入参数的类型决定返回类型，auto 与模板结合使得函数可以灵活地处理不同类型的参数。

3.3. 与 Lambda 表达式结合

在函数重载中，auto 可以与 Lambda 表达式结合使用，提供灵活的参数处理方式。

auto process(int i) {
    // Process integer
    return i * 2;
}

auto process(double f) {
    // Process floating point
    return f * 2.5;
}

auto process(const std::string& s) {
    // Process string
    return s + s;
}

在这个例子中，process 函数根据参数类型被重载，每个函数的实现针对不同的参数类型进行操作。

3.4. 与 decltype 结合解决复杂的类型推导

auto 与 decltype 结合可以在重载函数中解决复杂的类型推导问题。

auto make_pair(int i, double f) -> std::pair<int, decltype(f)> {
    return {i, f};
}

auto make_pair(const std::string& s1, const std::string& s2) 
    -> std::pair<decltype(s1), decltype(s2)> {
    return {s1, s2};
}

在这个例子中，make_pair 函数根据参数类型被重载，auto 与 decltype 结合使得返回类型可以根据参数类型自动推导。

3.5.注意事项

  • 在使用 auto 进行函数重载时，确保每个重载版本的函数签名（包括参数类型和返回类型）是唯一的，以避免重载冲突。
  • 在某些复杂的重载场景中，可能需要显式指定类型，以确保正确的重载选择。

通过这些应用，auto 关键字可以帮助开发者编写更简洁、更易于维护的代码，尤其是在处理模板和重载函数时。

4.如何使用auto关键字来简化模板类的成员函数声明？

在 C++11 中，auto 关键字可以用于模板类成员函数的返回类型，以简化代码并减少冗余。这在模板编程中特别有用，因为模板通常需要处理多种不同的数据类型。

4.1.基本用法

在模板类的成员函数中使用 auto 关键字，可以让编译器自动推导返回类型，从而使代码更加简洁和清晰。

4.1.1.示例：简单的模板类
#include <iostream>
#include <vector>

template <typename T>
class MyClass {
public:
    auto add(const T& a, const T& b) const -> T {
        return a + b;
    }

    auto getSquare(size_t index) const -> decltype(std::vector<T>{index, index}[index]) {
        return std::vector<T>{index, index}[index] * std::vector<T>{index, index}[index];
    }
};

int main() {
    MyClass<int> intObj;
    std::cout << "Sum: " << intObj.add(3, 4) << std::endl; // 输出 7

    MyClass<double> doubleObj;
    std::cout << "Sum: " << doubleObj.add(3.5, 4.5) << std::endl; // 输出 8.0

    MyClass<size_t> sizeObj;
    std::cout << "Square: " << sizeObj.getSquare(3) << std::endl; // 输出 9
    return 0;
}

在这个例子中，add 函数的返回类型由参数 a 和 b 的类型决定，而 getSquare 函数返回一个类型为 size_t 的值，其大小为 index 的平方。

4.2.使用尾置返回类型

在 C++11 中，auto 必须与尾置返回类型一起使用，以便编译器可以清楚地看到用于类型推导的完整表达式。

4.2.1.示例：使用尾置返回类型
template <typename T>
class Processor {
public:
    auto process(T value) -> decltype(value * 2) {
        return value * 2;
    }
};

int main() {
    Processor<int> intProcessor;
    std::cout << "Processed: " << intProcessor.process(5) << std::endl; // 输出 10

    Processor<double> doubleProcessor;
    std::cout << "Processed: " << doubleProcessor.process(5.5) << std::endl; // 输出 11.0
    return 0;
}

在这个例子中，process 函数的返回类型是通过 decltype 推导出来的，这允许编译器根据表达式 value * 2 来确定返回类型。

4.3.注意事项

  1. 类型推导时机：auto 关键字的类型推导是在编译时进行的，这意味着返回类型完全由编译器根据表达式推导出来。

  2. 尾置返回类型：在模板中使用 auto 时，必须使用尾置返回类型语法，以便编译器能够正确推导返回类型。

  3. 复杂表达式：当推导的类型依赖于复杂的表达式时，使用 decltype 可以帮助编译器正确理解应该推导的类型。

  4. 编译器支持：确保你的编译器支持 C++11 或更高版本，以便正确处理 auto 和尾置返回类型。

通过在模板类中使用 auto，你可以编写更灵活、更简洁的代码，同时让编译器自动处理类型推导，减少出错的可能性。

5.在C++14中，auto关键字有哪些新的用法或特性？

在 C++14 中，auto 关键字得到了扩展，带来了一些新的用法和特性：

  1. 函数返回类型推导：C++14 允许在函数定义中直接使用 auto 来推导返回类型，而不需要在函数声明中使用尾置返回类型。这意味着编译器会根据函数体中的返回语句来自动确定返回类型。例如：

    auto functionName() {
    // ...
    return someExpression;
}

    这使得代码更加简洁，尤其是在模板编程中。

  2. Lambda 表达式参数类型推导：C++14 允许在 Lambda 表达式中使用 auto 来推导参数类型。这使得 Lambda 表达式可以更灵活地接受不同类型的参数：

    auto lambda = [](auto param) {
    // ...
};

    这种用法使得 Lambda 表达式更像是泛型的，可以根据传入的参数类型自动适应。

  3. 结构化绑定：虽然这不是 auto 的直接新用法，但 C++17 进一步扩展了 auto 的应用，允许与结构化绑定一起使用，从而简化了对元组或 pair 类型中多个成员的访问：

    auto [a, b] = somePair;

    这使得代码更加简洁和易读。

  4. decltype(auto)：C++14 引入了 decltype(auto)，它用于模板元编程中，可以保留表达式的结果类型，包括它的值类别（左值或右值）和 const/volatile 限定符。这在编写泛型代码时非常有用，尤其是在需要转发参数的时候：

    template <typename T>
decltype(auto) function(T&& arg) {
    return std::forward<T>(arg);
}

    这里，decltype(auto) 允许编译器推导出最“适合”的类型，从而实现完美转发。

  5. 非类型模板参数：C++17 进一步扩展了 auto 的使用，允许它作为非类型模板参数的占位符，这在某些元编程技术中非常有用。

这些新特性使得 auto 关键字更加强大和灵活，能够进一步简化模板编程和泛型编程的复杂性。

关于作者

WeSiGJ
关注
专栏目录
c++学习笔记（个人学习时做的笔记）
11-27
5. **自动类型推导（Automatic Type Deduction）**：C++11引入的`auto`关键字可以根据初始值自动推导变量类型，简化代码。 6. **decltype**：根据表达式的类型推导出变量类型，常用于元编程或模板编程。 ### 数据...
Automatic Type Deduction: auto (C++11) 自动类型推导：auto关键字
Parker盘的博客
07-20 641
Automatic Type Deduction: auto (C++11) 自动类型推导：auto关键字 1. 关键字 auto C++03及之前的标准种，auto放在变量声明之前，声明变量的存储策略。但是这个关键字常省略不写。 C++11中，auto关键字放在变量之前，作用是在声明变量的时候根据变量初始值的类型自动为此变量选择匹配的类型 例如： int a = 10; auto au_a = a;//自动类型推断，au_a为int类型 cout << typeid(au_a).nam
C++程序设计（面向对象进阶）崔毅东 ——第3单元第03节——2Automatic Type Deduction: decltype（自动类型推导：decltype关键字）
qq_33934599的博客
03-25 164
Automatic Type Deduction: decltype（自动类型推导：decltype关键字） 1. 关键字decltype的用法 decltype利用已知类型声明新变量。 有了auto，为什么还要整出一个decltype？原因是，我们有时候想要从表达式的类型推断出要定义的变量类型，但不想用该表达式的值初始化变量。 decltype是在编译期推导一个表达式的类型，它只做静态分...
C++17尝鲜：类模板中的模板参数自动推导
danshiming的博客
02-11 2066
目录 模板参数自动推导 示例 自定义类模板中的应用 Automatic deduction guides（自动推断向导） 模板参数自动推导 在C++17之前，类模板构造器的模板参数是不能像函数模板的模板参数那样被自动推导的，比如我们无法写 std::pair a{1, "a"s}; // C++17 而只能写 std::pair<int, string> a{1, "a"s}; // C++14 为了弥补这一缺陷，标准库为我们提供了 std::make_pair 函数，通过函数.
【C++ | 进阶】（侯捷）C++11/14新特性
Midnight_city的博客
08-02 1776
C++11/14新特性 〇、概述 C++Standard演化：C++98（1.0）、C++03（TR1）、C++11（2.0）、C++14（对11一些地方的加强） C++2.0新特性包括语言和标准库层 Header files 区别： C++标准库的header files不带副档名(.h)，例如#incldue<vector> 新式C header files不带副名称(.h)，例如#inlcude<cstdlio> 旧式C header files带有副名称(.h)，例如#in
【C++ grammar】Enhancement for Type System (C++11 对类型系统的增强)
hanhan的博客
10-03 331
数据类型 (Data type) int, long int, double, struct, char *, float [], int (*f)()… 计算机程序构造块 计算机程序构造块是不同大小粒度的计算机程序组成部分，它包括变量、表达式、函数或者模块等。 类型系统 (Type System) 类型系统：在编程语言中，“类型系统”是将“type”属性指定给不同计算机程序构造块的规则集 为什么使用类型系统：减少程序中可能出现的bug 1、定义不同程序块之间的接口 2、检查多个块之间是否以一致的方式连
新标准C++11-14
小小博客
03-26 634
前言 1.演进、环境与资源 2.Variadic Templates 3.Spaces in Template Expression、nullptr and std–nullptr_t、Automatic Type Deduction with auto 4.Unform Initialization 5.Initializer_list 6.Explicit for ctors taking more than one argument 7.Range -based for statement 8. =d
c++11 新特性 侯捷
小渣渣的博客
07-16 855
11之前，用于一个参数的构造函数。有上面的代码，那么在执行complex c1(12, 5);的时候，构造函数不用explicit修饰，则会把5变成一个复数类，但是如果用explicit修饰了，这两句代码就会报错。也就是，让编译器知道，用户希望只在显式调用构造函数的时候才会调用，其他时候不允许调用。11之后，explicit可用在接受一个以上参数的构造函数。突破了一个参数的限制，阻止任意多个参数的构造函数的隐式调用。
C++程序设计（面向对象进阶）崔毅东 ——第3单元第03节——1auto (C++11) 自动类型推导：auto关键字
qq_33934599的博客
03-24 285
Automatic Type Deduction: auto (C++11) 自动类型推导：auto关键字 1.关键字 auto C++03及之前的标准中，auto放在变量声明之前，声明变量的存储策略。但是这个关键字常省略不写。 C++11中，auto关键字放在变量之前，作用是在声明变量的时候根据变量初始值的类型自动为此变量选择匹配的类型 例如： int a = 10; auto au_a = ...
C++基础与深度解析 | 对象与基本类型 | 初始化/赋值语句 | 类型 | 复合类型 | 常量类型与常量表达式 | 类型别名与类型的自动推导 | 作用域与对象的生命周期
zwcslj的博客
05-14 676
  初始化 / 赋值语句是程序中最基本的操作，其功能是将某个值与一个对象关联起来。值（等号右边）可以是字面值，也可以是对象（变量或常量）所表示的值。表示对象的标识符（等号左边）可以是变量、常量、引用等。值与对象都有类型，并且需要注意的是：初始化/赋值可能涉及到类型转换。  初始化是在创建对象时给对象指定一个初始值的过程。初始化通常发生在对象的声明时，确保了对象在定义后就处于一个确定的状态。初始化的基本操作：首先，在内存中开辟空间，保存相应的数值；然后，在编译器中构造符号表，将标识符与相关内存空间关联起来。直
c++ 类型自动推导
09-19
在C++中，类型自动推导（Automatic Type Deduction，也称为隐式类型转换）主要是指编译器能够根据操作符两边的表达式自动确定所需的操作数类型。这种功能主要应用于函数模板、运算符重载以及自动引用等场景。 1. ...
C++11/14精华：现代C++高效实践
- Item 1: 自动类型推导（Automatic Type Deduction）是C++11的一项特性，它能自动确定函数参数或表达式的类型，减少冗余类型声明。 - Item 2: `decltype` 是一个关键字，用于获取表达式的类型信息，这对于动态...
C++学习笔记：从基础到C++11特性解析
4. 自动类型推导（Automatic Type Deduction）：C++11引入的auto关键字可以自动推断变量的类型，简化了代码。decltype则根据表达式的类型来定义变量，通常用于模板编程。 5. C++内存模型：理解内存模型是理解C++的...
C语言 | 第十章 | 函数 作用域
ZJC744575的博客
10-05 1287
为完成某一功能的程序指令(语句)的集合,称为函数。在C语言中,函数分为:自定义函数、系统函数(查看C语言函数手册)函数还有其它叫法，比如方法等，在本视频课程中，我们统一称为 函数。返回类型 函数名（形参列表）{执行语句...;// 函数体return 返回值;// 可选形参列表：表示函数的输入函数中的语句：表示为了实现某一功能代码块函数可以有返回值,也可以没有, 如果没有返回值，返回类型 声明为 void。
【C++】List
m0_46676283的博客
10-08 343
文章目录1.list的介绍及使用1.1 list的介绍 本节目标 1.list的介绍及使用 2.list的深度剖析及模拟实现 3.list与vector的对比 4.本节习题 1.list的介绍及使用 1.1 list的介绍
C语言 | Leetcode C语言题解之第472题连接词
m0_59237910的博客
10-11 305
C语言 | Leetcode C语言题解之第472题连接词
[C++ 核心编程]笔记 5 函数提高
最新发布
qq_42995393的博客
10-11 179
作用:函数名可以相同，提高复用性同一个作用域下函数名称相同函数参数类型不同 或者 个数不同 或者 顺序不同注意: 函数的返回值不可以作为函数重载的条件//原函数cout
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

WeSiGJ

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值