想从表达式推断出要定义的变量的类型，但不想计算表达式的值，此时可以使用decltype
语法是：delctype(表达式)，其中表达式可以是变量、函数、数组等。

#include 

#include 

namespace test_decltype { 



double onlyDeclartionFunc();

auto main() -> int { 



std::cout << "testing decltype..." << std::endl;

/* 表达式是函数 */

decltype(onlyDeclartionFunc()) sum = 34;   // 使用decltype根据函数类型推断类型时可以仅要求函数有声明，不要求函数有定义

std::cout << "type(sum) is: " << typeid(sum).name() << std::endl;  // double

/***************************************************************************/

float i = 3.4f;

decltype(i) a = 52;

std::cout << "type(a) is: " << typeid(a).name() << std::endl;     // float

// 使用decltype时会返回变量的真实类型(包括const和引用)，这与auto有区别

const int ci = 0;        // const int

const int &cj = ci;      // const int &

decltype(ci) b = 9;      // const int

// b = 10; // error C3892: “b”: 不能给常量赋值

decltype(cj) c = b;      // const int &

// c = ci; // error C3892: “c”: 不能给常量赋值

decltype(cj) d = 9;     // const int &

// decltype(cj) e; // error C2530: “e”: 必须初始化引用

std::cout << "type(ci) is: " << typeid(ci).name() << std::endl;  // const int（ps:编译器输出时不会带const，下同）

std::cout << "type(cj) is: " << typeid(cj).name() << std::endl;  // const int &

std::cout << "type(b) is: " << typeid(b).name() << std::endl;    // const int

std::cout << "type(c) is: " << typeid(c).name() << std::endl;    // const int &

std::cout << "type(d) is: " << typeid(d).name() << std::endl;    // const int &

/***************************************************************************/

// decltype(表达式)推断出引用类型的几种情况:

// 1. 表达式本身是引用;

// 2. 表达式是指针的解引用;

// 3. 表达式加括号;

int j = 0;

int &k = j;

int *p = &j;

std::cout << "Original j, 0 == " << j << std::endl;

decltype(k) f = k;     // f是j的引用(表达式本身是引用)

f = 1;

std::cout << "f is j's reference, 1 == " << j << std::endl;

decltype(*p) g = j;    // g是j的引用(表达式是指针的解引用)

g = 2;

std::cout << "g is j's reference, 2 == " << j << std::endl;

decltype((j)) h = j;   // h是j的引用(表达式加括号)

h = 3;

std::cout << "h is j's reference, 3 == " << j << std::endl;

decltype(k+0) m = k;   // m是int,不是int&,因为k+0是int类型

m = 4;

std::cout << "m is not j's reference, 4 != " << j << std::endl;

// 对数组使用decltype**得到的是数组类型

int arr[] = { 

3,4,5};

// decltype(arr) crr = {5,6,7,8,9}; // error: too many initializers for 'int [3]'

decltype(arr) drr = { 

5,6,7};           // 注意,数组元素的个数是数组类型的一部分

std::cout << "type(drr) is: " << typeid(drr).name() << std::endl;   // int [3]

/***************************************************************************/

std::cout << "------------------------------" << std::endl;

return 0;

}

}

以上程序的输出：

testing decltype...

type(sum) is: double

type(a) is: float

type(ci) is: int

type(cj) is: int

type(b) is: int

type(c) is: int

type(d) is: int

Original j, 0 == 0

f is j's reference, 1 == 1 g is j's reference, 2 == 2

h is j's reference, 3 == 3 m is not j's reference, 4 != 3

type(drr) is: int [3]

对数组使用decltype得到的是数组类型，与auto不同

// 对数组使用decltype

int arr[] = { 

3,4,5};

// decltype(arr) crr = {5,6,7,8,9}; // error: too many initializers for 'int [3]'

decltype(arr) drr = { 

5,6,7};           // 注意,数组元素的个数是数组类型的一部分

std::cout << "type(drr) is: " << typeid(drr).name() << std::endl;   // int [3]