c++0x 学习笔记 1 ---- auto

 

auto :  类型自动推导 ( type deduction )

 

考虑下边这一行程序

auto a1 = 1;

由于 auto 的自动类型推导，a1 自动被编译器识别为 int 类型。更一般的使用方式是这样的：

auto a1 = expression;

也就是说，有了auto之后，变量类型可以由编译器自动从初始化的表达式中识别出来：

int f();
auto a1 = f();

对模板也有用：

template<typename T1, typename T2>
double sum( T1& t1, T2& t2 )
{
    auto ans = t1 + t2;
    return ans;
}

这看起来有些无聊而且降低了程序的可读性，不过在类型相当复杂的时候非常有用 ：

std::map<std::string, std::string> m;
//for ( std::map<std::string, std::string>::iterator i = m.begin(); i != m.end(); ++i )
for ( auto i = m.begin(); i != m.end(); ++i )
    ...

而且，得益于 c++0x 新型的 for 循环控制，更方便的写法是：

for ( auto i : m )
    ...

当然，如果想修改 m 元素的内容，就要用引用：

for ( auto& i : m )
    ...

 

更进一步

 

auto 可以与 static，const，volatile，* 和 & 等一起用：

int f();
auto i1 = f();
const auto i2 = f();
const auto& = f();

再如：

int* f();
auto i = f();
auto* i = f();
const auto* i = f();

碰到引用时跟指针稍微有些区别：

int& f();
auto i1 = f(); 
auto& i2 = f();
const auto& i3 = f();

上边变量 i1 的类型是 int ，不是 int& 。

 

 

auto 在涉及到虚拟继承时候类型推导也没有什么问题：

struct b
{
    virtual void operator()() const
    {
        cout << "b()()\n";
    }
};

struct d : b
{
    virtual void operator()() const
    {
        cout << "d()()\n";
    }
};

    auto p1 = new d;
    (*p1)();
    auto p2 = p1;
    (*p2)();

    b* p3 = new d;
    auto p4 = p3;
    (*p4)();

输出都是 d()() 。

 

 

auto 直接初始化写法是非常容易上手的：

auto i = 1;
const auto i = 1;
static auto i = 1;
const auto& i = 1;

包括指针初始化：

int * i = new int(1);
auto i = new auto(1);
auto* i = new auto(1);

上边三句执行动作完全一样。

 

有多个变量要一起 auto 也行：

auto i = 1, j = 2;
auto i = 1, *j = &i;

auto k = 0;
auto* i = &k, j = 1;

只要不试图调戏编译器就可以：

auto i = &i;//error
auto i = 1, j = 1.0;//error

 

更多

 

一个比较无聊的用法可以是这样的：

auto int i;

变量 i 被定义为 int 类型，不需要初始化参量。

 

碰到数组时候稍微尴尬点：

auto v1 = {1, 2, 3};
auto v1[3] = {1, 2, 3};//error
auto v1[] = {1, 2, 3}; //error

int v[3];
auto v2 = v;
auto v2[3] = v;//error
auto v2[] = v; //error

 

编译环境:

linux 2.6.35

g++ 4.5

编译选项：

-std=c++0x

 

完整编译：

g++ –o test test.cc -std=c++0x

 

(感谢pengxinglove 建议)