《C++ Primer》第2章 2.5节习题答案

2.5处理类型

 

   

练习33：利用本节定义变量，判断下列语句的运行结果。
a = 42; b = 42; c = 42;
d = 42; e = 42; g = 42

【解答】
前3条赋值语句是合法的，原因如下：
r是i的别名，而i是一个整数，所以a的类型推断结果是一个整数；ci是一个整型常量，在类型推断时顶层const被忽略掉了，所以b是一个整数；cr是ci的别名，而ci是一个整型常量，所以c的类型推断结果是一个整数。因为a,b,c都是整数，所以为其赋值42是合法的。
后3条赋值语句是非法的，原因如下：
i是一个整数，&i是i的地址，所以d的类型推断结果是一个整型指针；ci是一个整型常量，&ci是一个整型常量的地址，所以e的类型推断结果是一个指向整型常量的指针；ci是一个整型常量，所以g的类型推断结果是一个整型常量的引用。因为d和e都是指针，所以不能直接用字面值常量为其赋值；g绑定到了整型常量，所以不能修改它的值。

练习34：基于上一个练习中的变量和语句编写一段程序，输出赋值前后变量的内容，你刚才的推断正确吗？如果不对，请反复研读本节的示例直到你明白错在何处为止。

#include <iostream>

int main()
{
    int i = 0, &r = i;
    auto a = r;  //a是一个整数(r是i的别名,而i是个整数)
    
    const int ci = i, &cr = ci;
    auto b = ci;  //b是一个整数(ci的顶层const特性被忽略掉了)
    auto c = cr;  //c是一个整数(cr是ci的别名,ci本身是一个顶层const)
    auto d = &i;  //d是一个整型指针(整数的地址就是指向整数的指针)
    auto e = &ci; //e是一个指向整型常量的指针(对常量对象取地址是一种底层const)
    int *p = nullptr;
    
    const auto f = ci;
    auto &g = ci;  //g是一个整型常量引用,绑定到ci
    std::cout << a << "   " << b << "   " << c << "   " << d << "  " << e << "  " << g << std::endl;
    
    a = 42;
    b = 42;
    c  = 42;
    //d = 42;  //错训：d是一个指针，赋值非法
    //e = 42;  //错训：e是一个指针，赋值非法
    //g = 42;  //错训：g是一个常量引用，赋值非法
    std::cout << a << "  " << b << "  " << c << "  " << d << "  " << e << "  " << g << std::endl;
    
    return 0;
}

练习35：判断下列定义推断出的类型是什么，然后编写程序进行验证。
const int i = 42;
auto j = i; const auto &k = i; auto *p = &i;
const auto j2 = i, &k2 = i;
【解答】
用于验证的程序是：

#include <iostream>
#include <typeinfo>

int main()
{
    const int i = 42;
    auto j = i;
    const auto  &k = i;
    auto *p = &i;
    const auto j2 = i, &k2 = i;
    float aa = 3.12;
    
    std::cout << typeid(i).name() << std::endl;
    std::cout << typeid(j).name() << std::endl;
    std::cout << typeid(k).name() << std::endl;
    std::cout << typeid(p).name() << std::endl;
    std::cout << typeid(j2).name() << std::endl;
    std::cout << typeid(k2).name() << std::endl;
    std::cout << typeid(aa).name() << std::endl;
    
    
    std::cout << "===========================" << std::endl;
    std::cout << typeid(int).name() << std::endl;
    std::cout << typeid(const int).name() << std::endl;
    std::cout << typeid(const int&).name() << std::endl;
    std::cout << typeid(double).name() << std::endl;
    std::cout << typeid(const double).name() << std::endl;
    std::cout << typeid(const double&).name() << std::endl;
    return 0;
}

练习36：关于下面的代码，请指出每一个变量的类型以及程序结束时它们各自的值。
int a = 3, b = 4;
decltype(a) c = a;
decltype((b)) d = a;
++c;
++d;
【解答】
在本题的程序中，初始情况下a的值是3、b的值是4。decltype(a) c=a;使用的是一个不加括号的变量，因此c的类型就是a的类型，即该语句等同于int c=a；，此时c是一个新整形变量，值为3。decltype((b)) d=a;
使用的是一个加了括号的变量，因此d的类型是引用，即该语句等同于int &d=a;，此时d是变量a的别名。
执行++c; ++d;时，变量c的值自增为4，因为d是a的别名，所以d自增1意味着a的值变成了4.当程序结束时，a, b, c, d的值都是4。

#include <iostream>
#include <typeinfo>

int main()
{
    int a = 3, b = 4;
    decltype(a) c = a;
    decltype((b)) d = a;
    std::cout << "a = " << a << "  b = " << b << "  c = " << c << "  d = " << d << std::endl;
    ++c;
    ++d;
    std::cout << "a = " << a << "  b = " << b << "  c = " << c << "  d = " << d << std::endl;
    
    return 0;
}

练习37：赋值是会产生引用的一类典型表达式，引用的类型就是左值的类型。也就是说，如果i是int，则表达式i=x的类型是int&。根据这一特点，请指出下面的代码中每一个变量的类型和值。
int a = 3, b = 4;
decltype(a) c = a;
decltype(a = b) d = a;
【解答】
根据decltype的上述性质可知，c的类型是int，值为3；表达式a=b作为decltype的参数，编译器分析表达式并得到它的类型作为d的推断类型，但是不实际计算该表达式，所以a的值不发生改变，仍然是3；d的类型是int&，d是a的别名，值是3；b的值一直没有发生改变，为4。

#include <iostream>

int main()
{
    int a = 3, b = 4;
    decltype(a) c = a;
    decltype(a = b) d = a;
    std::cout << "a = " << a << "  b = " << b << "  c = " << c << "  d = " << d << std::endl;
    
    a = 8;
    std::cout << "a = " << a << "  b = " << b << "  c = " << c << "  d = " << d << std::endl;
    
    return 0;
}

练习38：说明由decltype指定类型和由auto指定类型有何区别。请举出一个例子，decltype指定的类型与auto指定的类型一样；再举一个例子，decltype指定的类型与auto指定的类型不一样。
【解答】
auto和decltype的区别主要有三个方面：
第一，auto类型说明符用编译器计算变量的初始值来推断其类型，而decltype虽然也让编译器分析表达式并得到它的类型，但是不实际计算表达式的值。
第二，编译器推断出来的auto类型有时候和初始值的类型并不完全一样，编译器会适当地改变结果类型使其更符合初始化规刚。例如，auto一般会忽略掉顶层const，而把底层const保留下来，与之相反，decltype会保留变量的顶层const。
第三，与auto不同，decltype的结果类型与表达式形式密切相关，如果变量名加上了一对括号，则得到的类型与不加括号时会有不同。如果decltype使用的是一个不加括号的变量，则得到的结果就是该变量的类型；如果给变量加上了一层或多层括号，则编译器将推断得到引用类型。
一个用以说明的示例如下所示：

#include <iostream>
#include <typeinfo>

using namespace std;

int main()
{
    int a  = 3;
    auto c1 = a;
    decltype(a) c2 = a;
    decltype((a)) c3 = a;

    const int d = 5;
    auto f1 = d;
    decltype(d) f2 = d;

    std::cout << typeid(c1).name() << std::endl;
    std::cout << typeid(c2).name() << std::endl;
    std::cout << typeid(c3).name() << std::endl;
    std::cout << typeid(f1).name() << std::endl;
    std::cout << typeid(f2).name() << std::endl;

    c1++;
    c2++;
    c3++;
    f1++;
    //f2++;//错误：f2是整型常量，不能执行自增操作

    std::cout << a << " " << c1 << " " << c2 << " "
              << c3 << " " << f1 << " " << f2 << std::endl;
    
    return 0;
}

       对于第一组类型推断来说，a是一个非常量整数，c1的推断结果是整数，c2的推断结果也是整数，c3的推断结果由于变量a额外加了一对括号所以是整数引用。c1, c2, c3依次执行自增操作，因为c3是变量a的别名，所以c3自增等同于a自增，最终a, c1, c2，c3的值都变为4。
        对于第二组类型推断来说，d是一个常量整数，含有顶层const，使用auto推断类型自动忽略掉顶层const，因此f1的推断结果是整数；decltype则保留顶层const，所以f2的推断结果是整数常量。f1可以正常执行自增操作，而常量f2的值不能被改变，所以无法自增。