编译器的差异：临时对象做实参的可能编译不过？
下面的代码在vs2005可正常编译运行，但gcc似乎不行（偶用的cygwin），虽然vs2005对标准C++的支持已经有很大进步了。。
gcc版本如下：
D:\cygwin\bin> gcc -v
Reading specs from /usr/lib/gcc/i686-pc-cygwin/3.4.4/specs
Configured with: /gcc/gcc-3.4.4/gcc-3.4.4-1/configure --verbose --prefix=/usr --exec-prefix=/usr --sysconfdir=/etc --lib
dir=/usr/lib --libexecdir=/usr/lib --mandir=/usr/share/man --infodir=/usr/share/info --enable-languages=c,ada,c++,d,f77,
java,objc --enable-nls --without-included-gettext --enable-version-specific-runtime-libs --without-x --enable-libgcj --d
isable-java-awt --with-system-zlib --enable-interpreter --disable-libgcj-debug --enable-threads=posix --enable-java-gc=b
oehm --disable-win32-registry --enable-sjlj-exceptions --enable-hash-synchronization --enable-libstdcxx-debug : (reconfi
gured)
Thread model: posix
gcc version 3.4.4 (cygming special) (gdc 0.12, using dmd 0.125)
言归正传，
问题一：
void fun2(string &str)
{
cout < < str < < endl;
}
int main()
{
fun2(string( "hello, "));
}
gcc编译错误提示如下：
D:\cygwin\home\ADMINI~1\project\aboutCPP.cpp: In function `int main() ':
D:\cygwin\home\ADMINI~1\project\aboutCPP.cpp:35: error: invalid initialization of non-const reference of type 'std::string& ' from a temporary of type 'std::string '
D:\cygwin\home\ADMINI~1\project\aboutCPP.cpp:28: error: in passing argument 1 of `void fun2(std::string&) '
为什么非法？看起来似乎是由于临时对象是一个const对象？真的吗？
答案是否定的，下面的代码可以说明之：
class MyString
{
public:
int Data() { return m_data; }
MyString &Data(int val) { m_data = val; }
private:
int m_data;
};
int main()
{
cout < < MyString().Data(2).Data() < < endl;
}
说明临时对象是non-const的！
另外，无意中又发现一个问题。
问题二：
class MyString
{
public:
int Data() { return m_data; }
MyString &Data(int val) { m_data = val; }
private:
int m_data;
};
int main()
{
MyString conMyStr;
const MyString conMyStr2;
}
gcc编译报错如下：
D:\cygwin\home\ADMINI~1\project\aboutCPP.cpp: In function `int main() ':
D:\cygwin\home\ADMINI~1\project\aboutCPP.cpp:51: error: uninitialized const `conMyStr2 '
gcc对const的支持有问题吗（瞎猜的，怎可能）？这个错又怎么解释？
小弟比较穷，分不多，但暂时也找不到好的解释办法。
哪位大侠可指点一下，谢谢～！
[解决办法]
关于标准的解释
Initialization of a reference is trivial when the initializer is an
lvalue (an object whose address you can take; see §4.9.6). The
initializer for a 'plain ' T& must be an lvalue of type T. The
initializer for a const T& need not be an lvalue or even of type T.
In such cases (David ' 's notes: and only in such cases),
[1] first, implicit type conversion to T is applied if necessary (see §C.6);
[2] then, the resulting value is placed in a temporary variable of type T; and
[3] finally, this temporary variable is used as the value of the initializer.
Consider:
double& dr = 1; // error: lvalue needed
const double& cdr = 1; // ok
The interpretation of this last initialization might be:
double temp = double(1) ; // first create a temporary with the right value
const double& cdr = temp; // then use the temporary as the initializer for cdr
A temporary created to hold a reference initializer persists until
the end of its reference’s scope.
References to variables and references to constants are distinguished
because the introduction of a temporary in the case of the variable
is highly errorprone;
an assignment to the variable would become an assignment to the –
soon to disappear – temporary. No such problem exists for references
to constants, and references to constants are often important as
function arguments (§11.6).
[解决办法]
to Jofee(阿飞) ，请注意这一段的理解：
because the introduction of a temporary in the case of the variable
is highly errorprone;
an assignment to the variable would become an assignment to the –
soon to disappear – temporary. No such problem exists for references
to constants
第一句说的易出错指的是逻辑错误，而不是“临时对象销毁之后引用无效”，如果我没记错的话，C++中不存在无效引用。出了作用域，临时对象与引用一同消失。
这里第二句是关键：向一变量赋值可能导致赋值到一个马上就要消失的临时变量上去，而对于常量引用不存在这个问题。
很明显，问题就在于，向一个马上就要消失的变量赋值没有起到期望的作用，常量引用没问题是因为常量引用不允许赋值。
