C++ decltype类型说明符


本系列文章由 @yhl_leo 出品,转载请注明出处。
文章链接: http://blog.csdn.net/yhl_leo/article/details/50865552


1 基本语法

decltype 类型说明符生成指定表达式的类型。在此过程中,编译器分析表达式并得到它的类型,却不实际计算表达式的值。

语法为:

decltype( expression )

编译器使用下列规则来确定expression 参数的类型。

  • 如果 expression 参数是标识符或类成员访问,则 decltype(expression)expression 命名的实体的类型。如果不存在此类实体或 expression 参数命名一组重载函数,则编译器将生成错误消息。
  • 如果 expression 参数是对一个函数或一个重载运算符函数的调用,则 decltype(expression) 是函数的返回类型。将忽略重载运算符两边的括号。
  • 如果 expression 参数是右值,则 decltype(expression)expression类型。如果 expression参数是左值,则 decltype(expression) 是对 左值引用 类型的expression

给出如下示例代码:

int var;
const int&& fx(); 
struct A { double x; }
const A* a = new A();
语句类型注释
decltype(fx());const int &&对左值引用的const int
decltype(var);int变量 var 的类型
decltype(a->x);double成员访问的类型
decltype((a->x));const double&内部括号导致语句作为表达式而不是成员访问计算。由于a声明为 const指针,因此类型是对const double的引用。

2 decltype和引用

如果decltype使用的表达式不是一个变量,则decltype返回表达式结果对应的类型。但是有些时候,一些表达式向decltype返回一个引用类型。一般来说,当这种情形发生时,意味着该表达式的结果对象能作为一条赋值语句的左值:

// decltype的结果可以是引用类型
int i = 42, *p = &i, &r = i;
decltype(r + 0) b; // OK, 加法的结果是int,因此b是一个(未初始化)的int
decltype(*p) c; // Error, c是int&, 必须初始化

因为r是一个引用,因此decltype(r)的结果是引用类型,如果想让结果类型是r所指的类型,可以把r作为表达式的一部分,如r+0,显然这个表达式的结果将是一个具体的值而非一个引用。

另一方面,如果表达式的内容是解引用操作,则decltype将得到引用类型。正如我们所熟悉的那样,解引用指针可以得到指针所指对象,而且还能给这个对象赋值,因此,decltype(*p)的结果类型是int&而非int

3 decltypeauto

如果decltype使用的表达式是一个变量,则decltype返回该变量的类型(包括顶层const和引用在内):

const int ci = 0, &cj = ci;
decltype(ci) x = 0; // x的类型是const int
decltype(cj) y = x; // y的类型是const int&,y绑定到变量x
decltype(cj) z; // Error, z是一个引用,必须初始化
  • decltype的结果类型与表达式形式密切相关

对于decltype所用的引用来说,如果变量名加上了一对括号,则得到的类型与不加括号时会有所不同。如果decltype使用的是一个不加括号的变量,则得到的结果就是该变量的类型;如果给变量加上了一层或多层括号,编译器就会把它当成是一个表达式。

decltype((i)) d; // Error, d是int&, 必须初始化
decltype(i) e;   // OK, e是一个未初始化的int
  • 模板函数的返回类型
    • 在 C++11 中,可以结合使用尾随返回类型上的 decltype 类型说明符和 auto 关键字来声明其返回类型依赖于其模板参数类型的模板函数。
    • 在 C++14 中,可以使用不带尾随返回类型的 decltype(auto) 来声明其返回类型取决于其模板参数类型的模板函数。

例如,定义一个求和模板函数:

//C++11
 template<typename T, typename U>
auto myFunc(T&& t, U&& u) -> decltype (forward<T>(t) + forward<U>(u)) 
        { return forward<T>(t) + forward<U>(u); };

//C++14
template<typename T, typename U>
decltype(auto) myFunc(T&& t, U&& u) 
        { return forward<T>(t) + forward<U>(u); };

forward:如果参数是右值或右值引用,则有条件地将其参数强制转换为右值引用。)

附上一段源码:

#include <iostream>
#include <string>
#include <utility>
#include <iomanip>

using namespace std;

template<typename T1, typename T2>
auto Plus(T1&& t1, T2&& t2) -> 
   decltype(forward<T1>(t1) + forward<T2>(t2))
{
   return forward<T1>(t1) + forward<T2>(t2);
}

class X
{
   friend X operator+(const X& x1, const X& x2)
   {
      return X(x1.m_data + x2.m_data);
   }

public:
   X(int data) : m_data(data) {}
   int Dump() const { return m_data;}
private:
   int m_data;
};

int main()
{
   // Integer 
   int i = 4;
   cout << 
      "Plus(i, 9) = " << 
      Plus(i, 9) << endl;

   // Floating point
   float dx = 4.0;
   float dy = 9.5;
   cout <<   
      setprecision(3) << 
      "Plus(dx, dy) = " <<
      Plus(dx, dy) << endl;

   // String      
   string hello = "Hello, ";
   string world = "world!";
   cout << Plus(hello, world) << endl;

   // Custom type
   X x1(20);
   X x2(22);
   X x3 = Plus(x1, x2);
   cout << 
      "x3.Dump() = " << 
      x3.Dump() << endl;
}

运行结果为:

Plus(i, 9) = 13
Plus(dx, dy) = 13.5
Hello, world!
x3.Dump() = 42

参考资料:

<think>嗯,用户想要了解C++中的变量类型,包括详细说明和使用方法。首先,我需要回顾一下C++的基本变量类型,以及它们的特点和应用场景。根据提供的引用内容,特别是引用[1]和[2],用户可能希望了解如何选择合适的类型以及最佳实践。 首先,基础数据类型包括整型、浮点型、字符型、布尔型等。例如,int、short、long这些整型的不同之处在于它们的存储大小和范围。可能需要解释每个类型的具体占用字节数,这在不同系统上可能有所不同,但C++标准有最小长度的规定。比如,int通常至少是16位,但实际上在现代系统中通常是32位。 接下来是浮点型,如float和double的区别,它们的精度和适用场景。比如科学计算常用double,而float用于节省内存的情况。还有字符型char,用于存储单个字符,以及布尔型bool,只有true和false两个值。 然后是类型修饰符,比如signed、unsigned、short、long。这些修饰符如何改变数据类型的范围和存储方式。例如,unsigned int的范围是0到4,294,967,295,而signed int则是-2,147,483,648到2,147,483,647(假设是32位)。需要说明这些修饰符如何影响变量的使用,比如使用unsigned类型时要注意避免溢出和下溢。 复合数据类型也是重点,比如数组、结构体、枚举、联合体等。数组用于存储相同类型的元素集合,结构体允许不同数据类型的组合。枚举类型可以提高代码可读性,比如用枚举表示状态。联合体则用于共享内存空间的情况,但需要谨慎使用,因为同一时间只能有一个成员有效。 用户可能还关心类型转换,包括隐式转换和显式转换。隐式转换在运算时自动发生,比如将int赋值给double。显式转换则需要使用static_cast等操作符,这更安全,避免潜在的错误。需要强调避免不必要的类型转换,尤其是在精度丢失的情况下。 在C++11及以后的新特性中,auto关键字和decltype类型推导可以简化代码编写,特别是在处理复杂类型时。例如,auto可以根据初始化表达式自动推断变量类型,这在模板编程中非常有用。另外,nullptr替代了NULL,提供了更明确的空指针表示。 引用类型和指针的区别也是一个重要点。引用是变量的别名,必须在声明时初始化,而指针可以重新指向其他地址。需要解释它们的用法和适用场景,比如函数参数传递时使用引用可以避免拷贝开销。 作用域和生命周期部分,局部变量和全局变量的区别,静态变量的生命周期等。静态局部变量在函数调用之间保持其值,而普通局部变量在函数退出时销毁。 关于最佳实践,引用中提到要选择合适的类型、避免不必要的转换、合理使用const修饰符。例如,const可以保护变量不被意外修改,提高代码的健壮性。另外,推荐使用新特性如auto和nullptr,以提升代码的现代性和安全性。 用户提供的引用[3]讨论了条件变量的使用,但当前问题主要关注变量类型,所以这部分可能暂时不需要涉及。但如果有后续问题涉及多线程中的变量使用,可能需要结合条件变量和互斥锁来讲解变量的线程安全。 在回答结构上,应该先分类讲解各种变量类型,再讨论类型转换、新特性、作用域和最佳实践。每个部分给出代码示例,帮助理解。例如,展示如何声明不同整型变量,使用结构体和枚举,以及auto和decltype的示例。 可能还需要注意用户的实际需求,比如他们可能在实际编程中遇到类型选择的问题,或者类型转换导致的错误。因此,强调如何根据需求选择合适类型,以及如何避免常见错误是很重要的。 最后,相关问题部分需要生成与C++变量类型相关的问题,比如类型转换的注意事项、新特性的优势、不同整型的选择依据等,帮助用户进一步深入学习。</think># C++ 变量类型详解及使用教程 ## 一、基础数据类型 ### 1. 整型 | 类型 | 占用字节 (x64) | 范围 (含符号) | 示例代码 | |-------------|----------------|--------------------------------|--------------------------| | `short` | 2 | $-32768$ 到 $32767$ | `short s = 100;` | | `int` | 4 | $-2^{31}$ 到 $2^{31}-1$ | `int i = -5;` | | `long` | 4/8 | $-2^{31}$ 或 $-2^{63}$ | `long l = 100000L;` | | `long long` | 8 | $-2^{63}$ 到 $2^{63}-1$ | `long long ll = 1e18;` | ### 2. 浮点型 ```cpp float f = 3.14f; // 单精度(6-7位有效数字) double d = 3.1415926; // 双精度(15位有效数字) long double ld = 3.141592653589793238L; // 扩展精度 ``` ### 3. 字符与布尔 ```cpp char c = 'A'; // ASCII字符存储 wchar_t wc = L'中'; // 宽字符(Unicode) bool flag = true; // 逻辑值(true/false) ``` ## 二、类型修饰符 ### 符号控制 ```cpp unsigned int ui = 4294967295; // 0到$2^{32}-1$ signed char sc = -128; // $-128$到$127$ ``` ### 长度扩展 ```cpp long double ld = 3.1415926535L; long int li = 2147483647L; ``` ## 三、复合数据类型 ### 1. 数组与字符串 ```cpp int arr[5] = {1,2,3,4,5}; // 定长数组 char str[] = "Hello"; // C风格字符串 std::string s = "C++ String"; // C++字符串对象 ``` ### 2. 结构体与联合体 ```cpp struct Point { // 结构体 int x; double y; }; Point p = {5, 3.14}; union Data { // 联合体(共享内存) int i; float f; }; Data d; ``` ### 3. 枚举类型 ```cpp enum Color { RED=1, GREEN=2, BLUE=4 }; // 传统枚举 Color c = GREEN; enum class LogLevel : uint8_t { // C++11类型枚举 DEBUG, WARNING, ERROR }; ``` ## 四、类型转换 ### 1. 隐式转换 ```cpp double d = 5; // int → double int i = 3.14; // double → int (i=3) ``` ### 2. 显式转换 ```cpp // C风格转换(不推荐) float f = (float)3.1415; // C++转换操作符 int* p = static_cast<int*>(malloc(100)); const_cast<int&>(ci) = 5; // 移除const属性 ``` ## 五、C++11+新特性 ### 类型推导 ```cpp auto x = 5; // int auto str = "hello"; // const char* decltype(x) y = x * 2; // 推导为int std::vector<int> vec; auto it = vec.begin(); // 迭代器类型自动推导 ``` ### 空指针与类型别名 ```cpp int* ptr = nullptr; // 明确空指针(C++11) using StringVector = std::vector<std::string>; // 类型别名 StringVector sv; ``` ## 六、作用域与生命周期 ```cpp int global_var; // 全局变量(程序生命周期) void func() { static int count = 0;// 静态局部变量 int local = 5; // 自动存储期 count++; } ``` ## 七、最佳实践 1. **类型选择原则** - 整型优先选择`int`,内存敏感时用`short` - 浮点运算首选`double` - 字符处理优先使用`std::string` 2. **类型安全** ```cpp const int MAX = 100; // 常量声明 size_t len = str.size(); // 无符号长度类型 static_cast<float>(int_var); // 显式转换 ``` 3. **现代C++特性应用** ```cpp auto&& item = getItem(); // 万能引用 constexpr int SIZE = 100; // 编译期常量 ``` ## 八、常见问题解答 **Q1: `unsigned int`和`int`如何选择?** A1: 当确定数值不会为负时使用`unsigned`,如循环索引、位操作。注意避免混合使用导致的隐式转换问题[^2]。 **Q2: C++11的`auto`会降低性能吗?** A2: 不会,`auto`只是编译期类型推导工具,生成的机器码与显式声明类型完全一致[^1]。 **Q3: 何时使用`long double`?** A3: 需要高精度科学计算时(如天体物理计算),但需注意不同平台精度实现差异。
评论 7
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值