亚洲精品中文字幕在线,欧美区日韩区,久久人人爽人人爽

如何在遍历中使用 iterator/reverse_iterator 删除元素

Thu, 10 Jul 2014 01:42:00 GMT

摘要: 众所周知�Q�在使用�q�代器遍�?STL 容器�Ӟ��需要特别留意是否在循环中修改了�q�代器而导致�P代器失效的情形。下面我来�ȝ��一下在对各�U�容器进行正向和反向遍历�q�程中删除元素时�Q�正��更新�P代器的用法。本文完整源码：�Ҏ��查看
首先�Q�要明白使用正向�q�代器（iterator�Q�进行反向遍历是错误的用法，要不�q�嘛要有反向�q�代器呢�Q�reverse_iterator�Q�。其�ơ，�Ҏ��容器的特性，遍历删除操作的用法可以分��Z��l�，�W�一�l�是 list �?vector�Q�第二组�?map �?set�?nbsp; 阅读全文

�|�朝�?/a> 2014-07-10 09:42 发表评论

让gcc支持成员函数模板的trick

Fri, 12 Jul 2013 14:04:00 GMT

让gcc支持成员函数模板的trick

�|�朝�?(http://m.shnenglu.com/kesalin/)

本文遵��@“�|�名-非商业用�?保持一�?/a>”创作公用协议

gcc 4.7.3 不支持成员函数模板特化。如下代码：

#ifndef __MEMFUNTEMPLATE_H__
#define __MEMFUNTEMPLATE_H__

#include

class Base {};
class Derived : public Base {};

struct Functor {
    template  void function() {
        printf(" Primary template.\n");
    }

    template<>
    void function<int>(){
        printf(" Specialization for int.\n");
    }

    template<> void function() {
        printf(" Specialization for Base *.\n");
    }
};

class Tester {
public:
    static void DoTest()
    {
        Functor functor;
        functor.function<char>();
        functor.function<int>();
        functor.function();
        functor.function();
    }
};

#endif // __MEMFUNTEMPLATE_H__

�?VS2010 中编译运行是没有问题的，但在 gcc 4.7.3下，�~�译都通不�q�：

../src/MemFunTemplate.h:21:14: error: explicit specialization in non-namespace scope ‘struct Functor’

../src/MemFunTemplate.h:22:24: error: template-id ‘function<int>’ in declaration of primary template

../src/MemFunTemplate.h:26:14: error: explicit specialization in non-namespace scope ‘struct Functor’

../src/MemFunTemplate.h:26:38: error: template-id ‘function’ in declaration of primary template

../src/MemFunTemplate.h:26:21: error: ‘void Functor::function()’ cannot be overloaded

../src/MemFunTemplate.h:22:10: error: with ‘void Functor::function()’

../src/MemFunTemplate.cpp: In function ‘int main()’:

../src/MemFunTemplate.cpp:17:2: error: ‘DoTest’ is not a member of ‘Functor’

��Z��辑ֈ��q�似成员函数模板特化的效果，可以利用成员函数��L��板以及重载函数来实现�Q?br />

* MemFunTemplate.h

* Created on: Jul 12, 2013

* Author: http://blog.csdn.net/kesalin/

#ifndef MEMFUNTEMPLATE_H_

#define MEMFUNTEMPLATE_H_

#include

template

struct DummyIdentity {

typedef T type;

};

class Base {};

class Derived : public Base {};

struct Functor {

template void function() {

function(DummyIdentity());

}

private:

template

void function(DummyIdentity) {

printf(" Primary template DummyIdentity.\n");

}

void function(DummyIdentity<int>) {

printf(" overload function for DummyIdentity.\n");

}

void function(DummyIdentity) {

printf(" overload function for DummyIdentity.\n");

functor.function<char>();

functor.function<int>();

functor.function();

}

};

#endif /* MEMFUNTEMPLATE_H_ */

调用 DoTest() �q�行�l�果如下�Q?/p>

Primary template DummyIdentity.

overload function for DummyIdentity<int>.

overload function for DummyIdentity.

Primary template DummyIdentity.

注意�Q?/span>

VS2010 版本的代码，模板形参�?T�Q�在实例化不会进行隐式类型�{换。即�?nbsp;Derived * 当作实参调用的是��L��板，而不�?Base * 特化版本

而在 gcc 下，模板形参虽然也�ؓT�Q�但影响重蝲册��?function 参数为：DummyIdentity�Q�用不同的实际参数实例化该模板，得到的是一堆重载函数。因此用 Derived * 当作实参�Ӟ��调用的函数自然就是实例化�?nbsp;void function(DummyIdentity)了�?/p>

�|�朝�?/a> 2013-07-12 22:04 发表评论

[深入理解C++�Q�二�Q�]理解接口�l�承规则

Tue, 06 Nov 2012 13:21:00 GMT

摘要: 在前一��《[深入理解C++�Q�一�Q�]�c�d��转换�Q�Type Casting�Q�》中�Q�我详细讲述�?C++ 中�{型动作，以及使用规则。有�|�友说应该提及下《深度探�?C++ 对象模型》一书中的内容，其实他的意思是�Q�要是对 C++ 对象的内存布局不甚了解�Q�就惌��L��C++中的�c�d��转型�Q�对象切�Ԍ��虚函数调用等�Q�犹如脱��M��坚实的根基，惛_��建空中阁楹{��理�?C++ 对象的内存布局对学�?C++来说臛_��重要�Q�但我不打算�?C++ 对象的内存布局相关的文章，因�ؓ要站在前人的肩膀上，大牛陈皓已经��p��个主题写了三��图文�ƈ茂的文章�Q?
�Q�一�Q�，C++ 虚函数表解析
�Q�二�Q�，C++ 对象的内存布局�Q�上�Q?
�Q�三�Q�，C++ 对象的内存布局�Q�下�Q?

在��l�阅��L��文之前，��先阅读这三篇文章�Q�以更好地理解本�p�d��文章。在接下来的内容中，我将从重载，重写�Q�屏蔽等概念入手�Q�引入众多接口��承规则�?nbsp; 阅读全文

�|�朝�?/a> 2012-11-06 21:21 发表评论

Sun, 28 Oct 2012 13:44:00 GMT

摘要: �c�d��转换��是��给定类型的表达式�{换�ؓ另一�U�类型。C++中的转型可分��Z��U�：隐式�c�d��转换和显式类型�{换。下面将详细介绍�q�两�U��{型操作，以及各自的适用场景�Q�潜在问题，最�l�将�ȝ��使用�c�d��转换操作应牢记的原则�?nbsp; 阅读全文

�|�朝�?/a> 2012-10-28 21:44 发表评论

Thu, 11 Oct 2012 12:04:00 GMT

摘要: �?timeout = 0�Q?�?Sleep(0)�Q�如果线�E�调度器的可�q�行队列中有大于或等于当前线�E�优先��的就�l�线�E�存在，操作�pȝ��会将当前�U�程从处理器上移除，调度其他优先�U�高的就�l�线�E�运行；如果可运行队列中的没有就�l�线�E�或所有就�l�线�E�的优先�U�均低于当前�U�程优先�U�，那么当前�U�程会��l�执行，��像没有调用 Sleep(0)一栗��?

�?timeout > 0 �Ӟ��如：Sleep(1)�Q�会引发�U�程上下文切换：调用�U�程会从�U�程调度器的可运行队列中被移除一�D�|��_��q�个旉��D늺��{�于 timeout 所指定的时间长度。�ؓ什么说�U�等于呢�Q�是因�ؓ睡眠旉��单位为毫�U�，�q�与�pȝ��的时间精度有兟뀂通常情况下，�pȝ��的时间精度�ؓ 10 ms�Q�那么指定�Q意少�?10 ms但大�?0 ms 的睡眠时��_��均会向上求��gؓ 10 ms�?nbsp; 阅读全文

�|�朝�?/a> 2012-10-11 20:04 发表评论

Fri, 04 Jun 2010 10:38:00 GMT

摘要: 数学函数备䆾。。�?nbsp; 阅读全文

�|�朝�?/a> 2010-06-04 18:38 发表评论

【译】VC10中的C++0x�Ҏ�?part 3 : 声明之类�?

Sun, 07 Jun 2009 01:28:00 GMT

摘要: �q�一�p�d��文章介绍Microsoft Visual Studio 2010 中支持的C++ 0x�Ҏ��，目前有三部分�?
Part 1 �Q�介�l�了Lambdas�Q?赋予新意义的auto�Q�以�?static_assert�Q?
Part 2( 一 , �?, �?)�Q�介�l�了叛_��引用（Rvalue References�Q�；
Part 3�Q�介�l�了表达式类型（decltype�Q?

VC10中的C++0x�Ҏ�?Part 1,2,3 译文打包下蝲�Q�doc �?pdf 格式�Q�： �Ҏ��下蝲

本文是Part 3�?nbsp; 阅读全文

�|�朝�?/a> 2009-06-07 09:28 发表评论

Fri, 05 Jun 2009 07:09:00 GMT

【译】VC10中的C++0x�Ҏ�?Part 2 �Q?�Q�：叛_��引�?/span>

来源�Q?a title=vcvlog target=_blank>vcblog 作者：Stephan T. Lavavej ��译�Q?a title=飘飘白云的C++博客 href="http://m.shnenglu.com/kesalin" target=_blank>飘飘白云

(转蝲时请注明作者和出处。未�l�许可，请勿用于商业用�?

��?

�q�一�p�d��文章介绍Microsoft Visual Studio 2010 中支持的C++ 0x�Ҏ��，目前有三部分�?
Part 1 �Q�介�l�了Lambdas�Q?赋予新意义的auto�Q�以�?static_assert�Q?
Part 2( 一 , �?/a> , �?/a> )�Q�介�l�了叛_��引用（Rvalue References�Q�；
Part 3�Q�介�l�了表达式类型（decltype�Q?br>
VC10中的C++0x�Ҏ�?Part 1,2,3 译文打包下蝲�Q�doc �?pdf 格式�Q�： �Ҏ��下蝲

本文�?Part 2 的第三页

转发问题

在程序员不用写高度泛化的代码的时候，C++98/03 �?lvalue�Q?rvalue�Q?引用�Q�还有模板看��h��是很完美的。假设你要写一个完全泛化的函数 outer()�Q�这个函数的目的是将��L��数目个�Q意类型的参数传递（也就�?#8220;转发”�Q�给函数 inner()。已有很多不错的解决�Ҏ��Q�比�?factory 函数 make_shared(args) 是把 args 传给 T 的构造函敎ͼ�然后�q�回 shared_ptr。（�q�样��把 T 对象和用于对它进行引用计数的代码存储到同一块动态内存中�Q�性能上与侵入式引用计��C��样好�Q�；而像 function �q�样的包装类是把参数传给其内部存储的函数对象�Q�functor�Q�，�{�等。在�q�篇文章里，我们只对 outer() 是如何把参数传递给 inner() �q�部分感兴趣。至�?outer() 的返回类型是怎么军_��的是另外的问题（有时候很��单，�?make_shared(args) ��L��q�回 shared_prt�Q�）�Q�但要在完全搞定�q�个问题的一般化情况�Q�你��p��用到 C++0x�?decltype �Ҏ��了�Q��?/p>

如果不带参数�Q�就不存在这��L��问题�Q�那么带一个参数情况呢�Q�让我们��试写个 outer�Q�） �Q?/p>

template void outer(T& t) {

inner(t);

}

�?题来了，如果传给它的参数是非帔R�� rvalue�Q�那我们��无法调�?outer()。如�?inner() 接收 const int& 型的参数�Q�那 inner(5) 是可以通过�~�译的，但是 outer(5) ��q��译不�q�了。因�?T 会被推导�?int�Q?�?int& 是不能绑定到帔R�� 5 的�?/p>

好吧�Q�让我们试试�q�个�Q?/p>

template void outer(const T& t) {

inner(t);

}

如果 inner�Q�）接收 int& 型参敎ͼ�那就会违�?const 正确性，�~�译都过不了�?/p>

现在�Q�你可以重蝲两个分别�?T& �?const T& 参数�?outer�Q�）�Q�这��实��用。当你调�?outer�Q�）�Ӟ��像直接调用 inner�Q�）一栗��?/p>

可惜的是�Q�这中方法在多参数的情况下就�ȝ��了（译注�Q�要写的重蝲函数太多了）。你��得为每一个参数像 T1& �?const T1&, T2& �?const T2& �{�这栯��行重载，要重载的函数数目呈指数��增长。（VC9 SP1 �?tr1�Q�：bind() ��够让�h感到�l�望了，它�ؓ 5 个参数这么重载出�?63 个函数。如果不�q�么蛮干的话�Q�没有像�q�里的长��篏�q�ͼ�我们��很难跟使用者解释�ؓ什么不能调用用 1729 �q�样�?ravlue 做参数的函数。�ؓ了��生出�q�些重蝲函数使用了��o��Z��呕的预处理机�Ӟ��恶心��C��都不想知道它�Q��?/p>

�?C++98/03 中，转发问题是很严重的，而且本质上无解（必须求助于恶心的预处理机�Ӟ��q�会严重拖慢�~�译速度�Q�还让代码变得难以阅读）。�ȝ��Q?rvalue 优雅地解决了�q�个问题�?/p>

完美转发�Q?/strong> 模式

完美转发让你能简单而清晰地只写一个模板函数就可以转发所有的参数�l��Q意函敎ͼ�不管它带几个参数�Q�也不管参数�c�d��是什么。而且参数的非帔R��/帔R��Q?lvalue/rvalue 属性都能得以保留，让你可以像��?inner�Q�）一样��?outer�Q�）�Q�还可以�?move 语意一��L��从而获得额外的好处。（ C++0x 的变长模板技术解决了“��L��数目”�q�部分，我们在这里把 N 看做��L��数目�Q�。乍看之下很��奇�Q�实际上很简单：

C:\Temp>type perfect.cpp

#include

#include

using namespace std;

template struct Identity {

    typedef T type;

};

template T&& Forward(typename Identity::type&& t) {

    return t;

}

void inner(int&, int&) {

    cout << "inner(int&, int&)" << endl;

}

void inner(int&, const int&) {

    cout << "inner(int&, const int&)" << endl;

}

void inner(const int&, int&) {

  cout << "inner(const int&, int&)" << endl;

}

void inner(const int&, const int&) {

    cout << "inner(const int&, const int&)" << endl;

}

template void outer(T1&& t1, T2&& t2) {

    inner(Forward(t1), Forward(t2));

}

int main() {

    int a = 1;

    const int b = 2;

    cout << "Directly calling inner()." << endl;

    inner(a, a);

    inner(b, b);

    inner(3, 3);

    inner(a, b);

    inner(b, a);

    inner(a, 3);

    inner(3, a);

    inner(b, 3);

    inner(3, b);

    cout << endl << "Calling outer()." << endl;

    outer(a, a);

    outer(b, b);

    outer(3, 3);

    outer(a, b);

    outer(b, a);

    outer(a, 3);

    outer(3, a);

    outer(b, 3);

    outer(3, b);

}

C:\Temp>cl /EHsc /nologo /W4 perfect.cpp

perfect.cpp

C:\Temp>perfect

Directly calling inner().

inner(int&, int&)

inner(const int&, const int&)

inner(const int&, const int&)

inner(int&, const int&)

inner(const int&, int&)

inner(int&, const int&)

inner(const int&, int&)

inner(const int&, const int&)

inner(const int&, const int&)

Calling outer().

inner(int&, int&)

inner(const int&, const int&)

inner(const int&, const int&)

inner(int&, const int&)

inner(const int&, int&)

inner(int&, const int&)

inner(const int&, int&)

inner(const int&, const int&)

inner(const int&, const int&)

两行�Q�完��{发只用了两行�Q�够��z�吧�Q?/p>

�q�个例子�C��了怎么�?t1 �?t2 �?outer�Q�）透明地�{发给 inner�Q�）�Q?inner�Q�）可以知道它们的非帔R��/帔R��Q?lvalue/ravlue 属性，��像inner是被直接调用的那栗��?/p>

�?std�Q�：move() 一��P�� std::identify �?std::forward() 都是�?C++ 中定义的�Q?VC10 会有�Q?VC10 CTP中没有）。我��演�C�怎么来实现它们。（再次�Q�我��交替��?std::identity 和我�?Identity�Q?std::forward() 和我�?Forward()�Q�因��Z��们的实现是等��L��。）

现在�Q�让我们来揭开“��术“的神�U�面�U�，其实它靠的就是模板参数推导和引用折叠(reference collapsing)技术�?/p>

rvalue 引用�Q�模板参数推�?/strong>和引用折�?reference collapsing)

rvalue 引用与模板以一�U�特别的方式�怺�作用。下面是一个示例：

C:\Temp>type collapse.cpp

#include

#include

#include

using namespace std;

template struct Name;

template <> struct Name {

    static const char * get() {

        return "string";

    }

};

template <> struct Name {

    static const char * get() {

        return "const string";

    }

};

template <> struct Name {

    static const char * get() {

        return "string&";

    }

};

template <> struct Name {

    static const char * get() {

        return "const string&";

    }

};

template <> struct Name {

    static const char * get() {

        return "string&&";

    }

};

template <> struct Name {

    static const char * get() {

        return "const string&&";

    }

};

template void quark(T&& t) {

    cout << "t: " << t << endl;

    cout << "T: " << Name::get() << endl;

    cout << "T&&: " << Name::get() << endl;

    cout << endl;

}

string strange() {

    return "strange()";

}

const string charm() {

    return "charm()";

}

int main() {

    string up("up");

    const string down("down");

    quark(up);

    quark(down);

    quark(strange());

    quark(charm());

}

C:\Temp>cl /EHsc /nologo /W4 collapse.cpp

collapse.cpp

C:\Temp>collapse

t: up

T: string&

T&&: string&

t: down

T: const string&

T&&: const string&

t: strange()

T: string

T&&: string&&

t: charm()

T: const string

T&&: const string&&

�q�里藉由 Name 的显式规��D��明来打印出类型�?/p>

当我们调�?quark(up) �Ӟ��会进行模板参数推对{�?quark() 是一个带有模板参�?T 的模板函敎ͼ�但是我们�q�没有�ؓ它提供显式的�c�d��参数�Q�比如像 quark(up)�q�样的）。通过比较函数形参�c�d�� Type&& 和函数实参类型（一�?string �c�d��?lvalue�Q�我们就能推导出模板实参�c�d��。（译注�Q�原文用 argument 表示实参�Q�parameter 表示形参�Q?/p>

C++0x 会�{换函数实参的�c�d��和�Ş参的�c�d��Q�然后再�q�行匚w��?/p>

首先�Q��{换函数实参的�c�d��。这遵��@一�?strong>�Ҏ��规则(提案N2798

然后�Q��{换函数�Ş参的�c�d��。不��是 C++98/03 �q�是 C++0x 都会解除引用( lvalue 引用�?rvalue 引用�?C++0x 中都会被解除�?。在前面例子的四�U�情形中�Q�这��h��们会�?T&& 转换�?T �?/p>

于是�Q?T 会被�?/strong>�?/strong>成函�?/strong>�?/strong>�?/strong>转换之后�?/strong>�c?/strong>�?/strong>�?strong>up �?down 都是 lvalue�Q�它们遵循那条特�D�规则，�q�就是�ؓ什�?quark(up) 打印�?T:string&" �Q��?quark(down) 打印�?"T: cosnt string&"的原因�?strong>strange() �?charm() 都是叛_��|��它们遵��@一般规则，�q�就是�ؓ什�?quark(strange()) 打印�?"T: string" �?quark(charm()) 打印�?T: const string" 的原因�?/p>

替换操作会在�c�d��推导之后�q�行。模板�Ş�?T 出现的每一个地斚w��会被替换成推导出来的模板实参�c�d��。在 quark(string()) �?T �?string �Q�因�?T&& 会是 string&& 。同��P��?quark(charm()) 中，T �?const string �Q?因此 T&& �?const string&& 。但 quark(up) �?quark(down) 不同�Q�它们遵循另外的�Ҏ��规则�?/p>

�?quark(up) 中， T �?string& 。进行替换的�?T&& ��成�?string& && �Q�在 C++0x 中会折叠�Q�collapse�Q�引用的引用�Q?strong>引用折叠�?/strong>规则��是“lvalue 引用�?/strong>�?/strong>染性的”�?X& &, X& && �?X&& & 都会被折叠成 X& �Q�只�?X&& && 会被折叠�?X&& 。因�?string& && 被折叠成 string& 。在模板世界里，那些看�v来像 rvalue 引用的东西�ƈ不一定真的就是�?因�?quark(up) 被实例化�?quark() �Q�进�?T&& �l�替换与折叠之后变成 string& 。我们可以调�?Name::get() 来验证这个�?同样�Q?quark(down) 被实例化�?quark() �Q�进�?T&& �l�替换与折叠之后变成 const string& 。在 C++98/03中，你可能习惯了帔R��?constness)隐藏于模板�Ş参中(也就是说可以�?const Foo 对象作实参来调用形参�?T& 的模板函敎ͼ��像 T& 会是 const Foo& 一�?�Q�在 C++0x 中，左值属�?lvalueness) 也能隐藏于模板�Ş参中�?/p>

那好�Q�这两条�Ҏ��规则�Ҏ��们有什么媄响？�?quark() 内部�Q�类�?T&& 有着和传�l?quark() 的实参一��L��?叛_��属�?lvalueness/rvalueness)和常量性。这�?rvalue 引用��p��保持住左�?/strong>�?/strong>属性和帔R��性，做到完美转发�?/strong>

完美转发�Q?std::forward() �?std::identidy 是�?/strong>�?/strong>工作�?/strong>

让我们再来看�?outer() :

template void outer(T1&& t1, T2&& t2) {

    inner(Forward(t1), Forward(t2));

}

现在我们明白了�ؓ什�?strong> outer() 的�Ş参是 T1&& �?T2&& �c�d��的了�Q�因为它们能够保持住传给 outer() 的实参的信息。那��Z��么这里要调用 Forward() �?Forward() 呢？�q�记得么�Q�具�?lvalue 引用和具�?rvalue 引用都是 lvalue 。如�?outer() 调用 inner(t1, t2) �Q�那�?inner() ��L��会当 lvalue 来引�?t1 �?t2 �Q�这��q��坏了完美转发�?/p>

�q?�q�的是，不具�?lvalue 引用�?lvalue�Q�不具名 rvalue 引用�q�是 rvalue 。因此，��Z��?t1 �?t2 转发�l?inner()�Q�我们需要将它们传到一个帮助函��C��去，�q�个帮助函数�U�除它们的名字，保持住它们的属性信息。这��是 std::forward() 做的事情�Q?/p>

template struct Identity {

    typedef T type;

};

template T&& Forward(typename Identity::type&& t) {

    return t;

}

当我们调�?Forward(t1) �Q?Identidy �q�没有修�?T1 �Q�很快我们讲�?Identidy �?T1 做了什么）。因�?Forward() 接收 T1&& �Q�返�?T1&& 。这样就�U�除�?t1 的名字，保持�?t1 的类型信息（而不�?t1 是什么类型， string& 也好, const string& 也好, string&& 也好�?const string&& 也好�Q�。这�?inner() 看到�?Forward(t1) �Q�与 outer() 接收的第一个实参有着相同的信息，包括�c�d��Q�lvalueness/rvalueness�Q�常量性等�{�。完��{发就是这样工作的�?/p>

你可能会好奇如果不小心写�?Forward(t1) 又会怎样呢？�Q�这个错误还是蛮�׃�h的，因�ؓ outer() 接收的就�?T1&& t1 �Q�。很�q�运�Q�没什么坏事情会发生�?Forward() 接收与返回的都是 T1&& && �Q�这会被折叠�?T1&& 。于是，Forward(t1) �?Forward(t1) 是等��L��Q�我们更偏好前者，是因为它要短些�?/p>

Identidy 是做什么用的呢�Q��ؓ什么下面的代码不能工作�Q?/p>

template T&& Forward(T&& t) { // BROKEN

    return t;

}

如果 Forward() 像是上面那样�Q�它��p��被隐式调用（不带明确的模板参敎ͼ�。当我们传给 Forward() 一�?lvalue 实参�Ӟ��模板参数推导��׃��入了�Q�如我们前面看到的那样会��?T&& 变成 T&�Q�也��是变成一�?lvalue 引用。问题来了，即��形参 T1&& �?T2&& 指明�?rvalue 引用�Q�但�?outer() 中，具名�?t1 �?t2 却是 lvaue �Q�这个问题是我们一直想要解决的�Q��用上面那个错误的实现�Q?Forward(t1) 是可以工作的�Q��?Foarward(t1) 虽然能通过�~�译�Q�很�׃�h哦）但会出错�Q�就如它��是 t1 一栗��真是痛苦的源泉啊，因此�Q?strong>Identity 被用来阻止模板参数推�?/strong>�?strong>typename Identity::type 中的那对冒号��像�l�缘体，模板参数推导无法�I�越它，有模板编�E�经验的�E�序员应该对此很熟悉了，因�ؓ�q�在 C++98/03 �?C++0x 中是一��L��。（要解释这个是另外的事情了�Q?/p>

move �?/strong>意： std::move() 是�?/strong>�?/strong>工作�?/strong>

现在我们已经学习了模板参数推导和引用折叠的特�D�规则，让我们再来看�?std::move() :

template struct RemoveReference {

     typedef T type;

};

template struct RemoveReference {

     typedef T type;

};

template struct RemoveReference {

     typedef T type;

};

template typename RemoveReference::type&& Move(T&& t) {

   return t;

}

RemoveReference 机制基本上是复制 C++0x 中的 std::remove_reference 。�D例来��_��RemoveReference::type , RemoveReference::type �?RemoveReference::type 都是 string �?/p>

同样�Q?move() 机制也基本上是复�?C++0x 中的 std::move()�?

· 当调�?Move(string), string 是一�?lvalue �Ӟ�� T 会被推导�?string& �Q�于�?strong> Move() 接收的就�?string& (�l�折叠之�?�q�返�?string&& (�l?RemoveReference 之后)�?/p>

· 当调�?Move(const string), const string 是一�?lvalue �Ӟ�� T 会被推导�?const string& �Q�于�?Move() 接收的就�?const string&& (�l�折叠之�?�q�返�?const string&& (�l?RemoveReference 之后)�?/p>

· 当调�?Move(string), string 是一�?rvalue �Ӟ�� T 会被推导�?string �Q�于�?strong> Move() 接收的就�?string&& �q�返�?string&& �?/p>

· 当调�?Move(const string), const string 是一�?rvalue �Ӟ�� T 会被推导�?const string �Q�于�?Move() 接收的就�?const string&& �q�返�?const string&& �?/p>

�q�就�?Move() 如何保持其参数的�c�d��和常量性，�q�能�?lvalue 转换�?rvalue 的过�E��?/p>

�?/strong>��?/strong>

如果你想�?rvalue 引用有更多了解，你可以去��L��兛_��们的提案。要注意�Q�提案与现在的决定可能已�l�不同了�Q?rvalue 引用已经被整合到 C++0x 草案中来了，在那里它得到持箋的改�q�。有些提案或已不再正��，或已�q�时�Q�或已有了替代方案，��没有被采纳。无论怎样�Q�它们还是能提供一些有用信息的�?/p>

N1377, N1385, �?N1690 是主要的提案�Q?a >N2118 包含被整合进标准草案之前的最后版本�?N1784, N1821, N2377, �?N2439 记录�?#8220;��?Move 语意扩展�?*this ”的演化过�E�，�q�个也被整合�?C++0x 中来了，但还没有在VC10 中得到实现�?/p>

展望

N2812 “Rvalue 引用的安全问题（以及如何解决�Q?#8221; 提出了对初始化规则的修改�Q�它��止 rvalue 引用�l�定�?lvalue �?�q�不会媄�?move 语意和完��{发，所以它不会让你刚学到的新技术失效（它只是修改了 std::move() �?std::forward() 的实玎ͼ��?/p>

Stephan T. Lavavej

Visual C++ Libraries Developer

Published Tuesday, February 03, 2009 9:27 AM by vcblog

��译�Q?a href="http://m.shnenglu.com/kesalin/">飘飘白云

(转蝲时请注明作者和出处。未�l�许可，请勿用于商业用�?

< �W�一��?/a>�Q?�W�二��?/a>�Q?本页>

�|�朝�?/a> 2009-06-05 15:09 发表评论

Thu, 04 Jun 2009 01:37:00 GMT

【译】VC10中的C++0x�Ҏ�?part 2�Q?�Q?叛_��引�?/h3> 来源�Q?a title=vcvlog target=_blank>vcblog 作者：Stephan T. Lavavej ��译�Q?a title=飘飘白云的C++博客 href="http://m.shnenglu.com/kesalin" target=_blank>飘飘白云

(转蝲时请注明作者和出处。未�l�许可，请勿用于商业用�?

��?

�q�一�p�d��文章介绍Microsoft Visual Studio 2010 中支持的C++ 0x�Ҏ��，目前有三部分�?
Part 1 �Q�介�l�了Lambdas�Q?赋予新意义的auto�Q�以�?static_assert�Q?
Part 2( 一 , �?/a> , �?/a> )�Q�介�l�了叛_��引用（Rvalue References�Q�；
Part 3�Q�介�l�了表达式类型（decltype�Q?br>
VC10中的C++0x�Ҏ�?Part 1,2,3 译文打包下蝲�Q�doc �?pdf 格式�Q�： �Ҏ��下蝲

本文�?Part 2 �W�二��c�?

move 语意�Q�从 lvalue �U�d��

现在�Q�如果你喜欢用拷贝赋值函数来实现你的拯��构造函数该怎样做呢�Q�那你也可能试图�?move 拯��赋值函数来实现 move 构造函数。这样作是可以的�Q�但是你得小心。下面就是一个错误的实现�Q?/p>

C:\Temp>type unified_wrong.cpp

#include

#include

#include

using namespace std;

class remote_integer {

public:

    remote_integer() {

        cout << "Default constructor." << endl;

        m_p = NULL;

    }

    explicit remote_integer(const int n) {

        cout << "Unary constructor." << endl;

        m_p = new int(n);

    }

    remote_integer(const remote_integer& other) {

        cout << "Copy constructor." << endl;

        m_p = NULL;

        *this = other;

    }

#ifdef MOVABLE

    remote_integer(remote_integer&& other) {

        cout << "MOVE CONSTRUCTOR." << endl;

        m_p = NULL;

        *this = other; // WRONG

    }

#endif // #ifdef MOVABLE

    remote_integer& operator=(const remote_integer& other) {

        cout << "Copy assignment operator." << endl;

        if (this != &other) {

            delete m_p;

            if (other.m_p) {

                m_p = new int(*other.m_p);

            } else {

                m_p = NULL;

            }

        }

        return *this;

    }

#ifdef MOVABLE

    remote_integer& operator=(remote_integer&& other) {

        cout << "MOVE ASSIGNMENT OPERATOR." << endl;

        if (this != &other) {

          delete m_p;

            m_p = other.m_p;

            other.m_p = NULL;

        }

        return *this;

    }

#endif // #ifdef MOVABLE

    ~remote_integer() {

        cout << "Destructor." << endl;

        delete m_p;

    }

    int get() const {

        return m_p ? *m_p : 0;

    }

private:

    int * m_p;

};

remote_integer frumple(const int n) {

    if (n == 1729) {

        return remote_integer(1729);

    }

    remote_integer ret(n * n);

    return ret;

}

int main() {

    remote_integer x = frumple(5);

    cout << x.get() << endl;

    remote_integer y = frumple(1729);

    cout << y.get() << endl;

}

C:\Temp>cl /EHsc /nologo /W4 /O2 unified_wrong.cpp

unified_wrong.cpp

C:\Temp>unified_wrong

Unary constructor.

Copy constructor.

Copy assignment operator.

Destructor.

25

Unary constructor.

1729

Destructor.

Destructor.

C:\Temp>cl /EHsc /nologo /W4 /O2 /DMOVABLE unified_wrong.cpp

unified_wrong.cpp

C:\Temp>unified_wrong

Unary constructor.

MOVE CONSTRUCTOR.

Copy assignment operator.

Destructor.

25

Unary constructor.

1729

Destructor.

Destructor.

(�~�译器在�q�里�q�行了返回��g��?RVO)�Q�但不是具名�q�回��g��?NRVO)。就像我之前提到的，有些拯��构造函数被 RVO �?NRVO 优化掉了�Q�但�~�译器�ƈ不��L��能够做这��L��优化�Q�这时剩余的��q�� move 构造函数来优化�?

move 构造函��C��标记�?WRONG 的那一行，调用了拷贝赋值函敎ͼ��~�译能通过也能�q�行�Q�但�q�违背了 move 构造函数的本意。（译注�Q�因为那个拷贝赋值函数只是进行普通的拯��赋��|��而不�?move 赋��|��Q?/p>

�q�是怎么回事呢？��C��Q�在C++98/03中，具名 lvalue 引用是左�?�l�定语句 int& r = *p; r �?lvalue)�Q�不具名 lvalue 引用�q�是左�?�l�定语句 vector v(10, 1729)�Q?v[0] �q�回 int&�Q?你可以对�q�个不具�?lvalue 引用取址)。但�?rvalue 引用��׃��一样了�Q?/p>

�?/strong> 具名 lvalue 引用�?/strong> lvalue�?/strong>

�?/strong> 不具�?/strong> rvalue 引用�?/strong> rvalue�?/strong>

一个具�?rvalue 引用是一�?lvalue 是因为可以对它施加多重操作，重复使用。相反，如果它是一�?ravlue 的话�Q�那么对它施加的�W�一个操作能�?#8220;�H�取”它，而后�l�操作就没机会了。这里的“�H�取”是说不会被察觉到�Q�所以这是行不通的。另一斚w��Q�不具名 rvalue 引用不能被重复��用，所以它仍保持右�?rvalueness)语意�?/p>

如果你真的打��用 move 赋值函数来实现 move 构造函敎ͼ�你需要从 lvalue move�Q�就像是�?rvalue move 一栗��C++0x 中的 std::move() 具备�q�样的能力，VC10��会有这个（实际上，开发版中已�l�有了）�Q�但VC10 TCP版还没有�Q�所以我会教你从头做��P��

C:\Temp>type unified_right.cpp

#include

#include

#include

using namespace std;

template struct RemoveReference {

     typedef T type;

};

template struct RemoveReference {

     typedef T type;

};

template struct RemoveReference {

     typedef T type;

};

template typename RemoveReference::type&& Move(T&& t) {

    return t;

}

class remote_integer {

public:

    remote_integer() {

        cout << "Default constructor." << endl;

        m_p = NULL;

    }

    explicit remote_integer(const int n) {

        cout << "Unary constructor." << endl;

        m_p = new int(n);

    }

    remote_integer(const remote_integer& other) {

        cout << "Copy constructor." << endl;

        m_p = NULL;

        *this = other;

    }

#ifdef MOVABLE

    remote_integer(remote_integer&& other) {

        cout << "MOVE CONSTRUCTOR." << endl;

        m_p = NULL;

        *this = Move(other); // RIGHT

    }

#endif // #ifdef MOVABLE

    remote_integer& operator=(const remote_integer& other) {

        cout << "Copy assignment operator." << endl;

        if (this != &other) {

            delete m_p;

            if (other.m_p) {

                m_p = new int(*other.m_p);

            } else {

                m_p = NULL;

            }

        }

        return *this;

    }

#ifdef MOVABLE

    remote_integer& operator=(remote_integer&& other) {

        cout << "MOVE ASSIGNMENT OPERATOR." << endl;

        if (this != &other) {

            delete m_p;

            m_p = other.m_p;

            other.m_p = NULL;

       }

        return *this;

    }

#endif // #ifdef MOVABLE

    ~remote_integer() {

        cout << "Destructor." << endl;

        delete m_p;

    }

    int get() const {

        return m_p ? *m_p : 0;

    }

private:

    int * m_p;

};

remote_integer frumple(const int n) {

    if (n == 1729) {

        return remote_integer(1729);

    }

    remote_integer ret(n * n);

    return ret;

}

int main() {

    remote_integer x = frumple(5);

    cout << x.get() << endl;

    remote_integer y = frumple(1729);

    cout << y.get() << endl;

}

C:\Temp>cl /EHsc /nologo /W4 /O2 /DMOVABLE unified_right.cpp

unified_right.cpp

C:\Temp>unified_right

Unary constructor.

MOVE CONSTRUCTOR.

MOVE ASSIGNMENT OPERATOR.

Destructor.

25

Unary constructor.

1729

Destructor.

Destructor.

�Q�我��交替��?std::move() 和我自己�?Move()�Q�因为它们的实现是等��L��Q?std::move() 是怎样工作的呢�Q�目前，我只能跟你说�q�是“��法”。（后面会有完整的解释，�q�不复杂�Q�但它与模板参数推导和引用折叠（reference collapsing�Q�译注：引用的引用）�?养I��后面讲完��{发的时候我们还会遇到这两个东西�Q�。我可以用一个具体的例子来略�q?#8220;��法”�Q�给定一�?string �c�d��的左��|��像前面重载决议例子中�?up �Q�std::move(up) 调用 string&& std::move(string&)�Q�这个函数返回一个不具名�?rvalue 引用�Q�它是一�?rvalue。给定一�?string �c�d��?rvalue�Q�像前面重蝲册��例子中的 strange()�Q?std::move(strange()) 调用 string&& std::move(string&&)�Q�同栯��个函数还是返回一个不具名�?rvalue�Q�还�?rvalue�?/p>

std::move() 除了让你能用 move 复制函数来实�?move 构造函��C��外，�q�能在其他地方发挥作用。无��Z��Ӟ��只要你有一个左��|��而它的��g��不再重要了（例如�Q�它��被销毁或被赋��|��Q�你��可以��?std::move(你的左��D��辑ּ�) 来��?move 语意�?/p>

move 语意�Q�可�U�d��成员�Q?/strong>movable member)

C++0x 的标准类型（�?vector, string, regex�Q?都有 move 构造函数和 move 赋值函数。而且我们也已�l�看��C��如何在我们自��q��c�M��通过手动��理资源来实�?move 语意�Q�像前面�?remote_integer �c�）。如果类中包含可�U�d��数据成员�Q�像 vector, string, regex, remote_integer �Q�时该怎么办呢�Q�编译器不会自动帮我们自动��?move 构造函数和 move 赋值函敎ͼ�所以我们必��L��动编写它们。很�q�运�Q�有�?std::move() �~�写它们是很�Ҏ��的�?/p>

C:\Temp>type point.cpp

#include

#include

#include

using namespace std;

template struct RemoveReference {

     typedef T type;

};

template struct RemoveReference {

     typedef T type;

};

template struct RemoveReference {

     typedef T type;

};

template typename RemoveReference::type&& Move(T&& t) {

    return t;

}

class remote_integer {

public:

    remote_integer() {

        cout << "Default constructor." << endl;

        m_p = NULL;

    }

    explicit remote_integer(const int n) {

        cout << "Unary constructor." << endl;

        m_p = new int(n);

    }

    remote_integer(const remote_integer& other) {

        cout << "Copy constructor." << endl;

        if (other.m_p) {

            m_p = new int(*other.m_p);

        } else {

            m_p = NULL;

        }

    }

    remote_integer(remote_integer&& other) {

        cout << "MOVE CONSTRUCTOR." << endl;

        m_p = other.m_p;

        other.m_p = NULL;

    }

    remote_integer& operator=(const remote_integer& other) {

        cout << "Copy assignment operator." << endl;

        if (this != &other) {

            delete m_p;

            if (other.m_p) {

                m_p = new int(*other.m_p);

            } else {

                m_p = NULL;

            }

        }

        return *this;

    }

    remote_integer& operator=(remote_integer&& other) {

        cout << "MOVE ASSIGNMENT OPERATOR." << endl;

        if (this != &other) {

            delete m_p;

            m_p = other.m_p;

            other.m_p = NULL;

        }

        return *this;

    }

    ~remote_integer() {

        cout << "Destructor." << endl;

        delete m_p;

    }

    int get() const {

        return m_p ? *m_p : 0;

    }

private:

    int * m_p;

};

class remote_point {

public:

    remote_point(const int x_arg, const int y_arg)

        : m_x(x_arg), m_y(y_arg) { }

    remote_point(remote_point&& other)

        : m_x(Move(other.m_x)),

          m_y(Move(other.m_y)) { }

    remote_point& operator=(remote_point&& other) {

        m_x = Move(other.m_x);

        m_y = Move(other.m_y);

        return *this;

    }

    int x() const { return m_x.get(); }

    int y() const { return m_y.get(); }

private:

    remote_integer m_x;

    remote_integer m_y;

};

remote_point five_by_five() {

    return remote_point(5, 5);

}

remote_point taxicab(const int n) {

    if (n == 0) {

        return remote_point(1, 1728);

    }

    remote_point ret(729, 1000);

    return ret;

}

int main() {

    remote_point p = taxicab(43112609);

    cout << "(" << p.x() << ", " << p.y() << ")" << endl;

    p = five_by_five();

    cout << "(" << p.x() << ", " << p.y() << ")" << endl;

}

C:\Temp>cl /EHsc /nologo /W4 /O2 point.cpp

point.cpp

C:\Temp>point

Unary constructor.

Unary constructor.

MOVE CONSTRUCTOR.

MOVE CONSTRUCTOR.

Destructor.

Destructor.

(729, 1000)

Unary constructor.

Unary constructor.

MOVE ASSIGNMENT OPERATOR.

MOVE ASSIGNMENT OPERATOR.

Destructor.

Destructor.

(5, 5)

Destructor.

Destructor.

现在你看到啦�Q�按成员�U�d��Q�memberwise move�Q�是很容易做到的。注意， remote_point �?move 赋值函数没有进行自我赋值检查，是因�?remote_integer 已经��查过了。也要注意到 remote_point 隐式声明的拷贝构造函敎ͼ�拯��赋值函数和析构函数都正常运作�?/p>

到现在，你应该对 move 语意已经非常熟悉了。（希望不是抓狂啊！�Q��ؓ了测试你新获得的�q�个不可思议的技能，请�ؓ前面的例子写一�?+() 操作�W�函数当作练习吧�?/p>

最后的提醒�Q�只要你的类支持 move 语意�Q�你��应该实�?move 构造函数和 move 赋值函数。因��Z��仅仅是你�q�_��使用�q�些�c�L��可从 move 语意中获利， STL 容器和算法也能从中获利，通过廉�h�?move 省下昂贵的拷贝开销�?/p>

(转蝲��h��明出处，作者与译者信息，请勿用于商业用�?

< 前一��?/a> 后一��?>

�|�朝�?/a> 2009-06-04 09:37 发表评论

Mon, 01 Jun 2009 12:40:00 GMT
     摘要: �q�一�p�d��文章介绍Microsoft Visual Studio 2010 中支持的C++ 0x�Ҏ��，目前有三部分�?
Part 1�Q�介�l�了Lambdas�Q?赋予新意义的auto�Q�以�?static_assert�Q?
Part 2�Q�介�l�了叛_��引用（Rvalue References�Q�；
Part 3�Q�介�l�了表达式类型（decltype�Q��?

本文为Part 2 的第一��c�?nbsp; 阅读全文

�|�朝�?/a> 2009-06-01 20:40 发表评论

【译】VC10中的C++0x�Ҏ�?part 1�Q�Lambdas�Q�auto�Q�以�?static_assert

Thu, 28 May 2009 03:27:00 GMT
     摘要: Microsoft Visual Studio 2010所带的Visual C++�~�译器对四个C++0x语言�Ҏ��提供了支持�Q�也��是 lambdas�Q�auto�Q�static_assert�Q�以�?rvalue references 。今天，我将详细介绍前三个特性。（很快我将贡献一整篇�q�的文章来解释右值引用，仅仅是因为再在这里解释的话将会加大这��已�l�很长的文章的篇�q�）  阅读全文

�|�朝�?/a> 2009-05-28 11:27 发表评论

Head First design patterns��M��W�记

Sun, 20 Jul 2008 15:31:00 GMT
     摘要: Head First design patterns��M��W�记  阅读全文

�|�朝�?/a> 2008-07-20 23:31 发表评论

C语言声明的优先��规则

Mon, 30 Jun 2008 15:33:00 GMT
     摘要: 《Expert C Programming�?《C专家�~�程�?中提到C语言声明的优先��规则如下�Q?

A 声明从它的名字开始读取，然后按照优先�U�顺序依�ơ读取；

B 优先�U�从高到低依�ơ是�Q?

B.1 声明中被括号括�v来的那部分；

B.2 后缀操作�W�：括号()表示�q�是一个函敎ͼ�而方括号[]表示�q�是一个数�l�；

B.3 前缀操作�W�：星号*标识“指�?..的指针”；

C 如果const�?或�?volatile关键字的后面紧跟�c�d��说明�W?如int�Q�long�{?�Q�那么它作用于类型说明符�Q�在其他情况下，const�?�?volatile关键字作用于它左边紧�ȝ��指针星号�?
  阅读全文

�|�朝�?/a> 2008-06-30 23:33 发表评论

【译】在C++中��用LUA

Tue, 17 Jun 2008 04:38:00 GMT
     摘要: Using LUA with C++

原文链接�Q�http://www.spheregames.com/index.php?p=templates/pages/tutorials

作者：http://www.spheregames.com

��译�Q�飘飘白云（http://m.shnenglu.com/kesalin �Q?

译注�Q�翻译本文�ƈ未获得原作者的许可�Q�翻译本文来仅供个�h学习消遣�Q�故谢却转蝲�?

原文中的�C�Z��代码汲取了《游戏编�E�精�_?5》中Matthew Harmon写的 “Building LUA into Games”一文的��x��与部分代码实玎ͼ�我将“Building LUA into Games”一文的�C�Z��代码应用到最新的LUA版本�Q�也打包贴在�q�里�Q�供大家参考�?

Using LUA with C++�Q�示例代码下�?

Building LUA into Gam  阅读全文

�|�朝�?/a> 2008-06-17 12:38 发表评论

亚洲精品中文字幕在线,欧美区日韩区,久久人人爽人人爽

如何在遍历中使用 iterator/reverse_iterator 删除元素

让gcc支持成员函数模板的trick

[深入理解C++�Q�二�Q�]理解接口�l�承规则

【译】VC10中的C++0x�Ҏ�?part 3 : 声明之类�?

【译】VC10中的C++0x�Ҏ�?part 1�Q�Lambdas�Q�auto�Q�以�?static_assert

Head First design patterns��M���W�记

C语言声明的优先��规则

【译】在C++中��用LUA

Head First design patterns��M��W�记