Java 为什么g++；使用+；将整数连接到字符串时不发出警告/错误=

我有以下代码：

#include <iostream>                     
using namespace std; 

int main()                  
{                                                                                    
       string name = "John ";                     
       int age = 32;         
       name += age;    
       cout << name << endl;
       return 0;                                          
}

   int a = 1;                                                                       
   float f = 3.33;                                                                  
   a = a + f;

我知道我们需要使用stringstream来完成任务。但是上面的代码为什么要编译呢？ 因为以下代码：

#include <iostream>
using namespace std;                                                                 

int main()                       
{                                                                                    
       string name = "John ";                              
       int age = 55;                                    
       name = name + age;             
       cout << name << endl;      
       return 0;
} 

   int a = 1;                                                                       
   float f = 3.33;                                                                  
   a = a + f;

与Java不同，无需担心可能丢失的精度警告。在C++中需要引用这个。

   int a = 1;                                                                       
   float f = 3.33;                                                                  
   a = a + f;

---

现在假设

name+=age扩展为
name=string（姓名+年龄）
那么代码也不应该仅仅因为名称+年龄是不合法的而编译。
您需要使用
-Wconversion
标志（我不清楚为什么不包括在-Wall中），也请参阅以了解更多详细信息。当我添加该标志时，我在使用
gcc
时看到以下警告：

   int a = 1;                                                                       
   float f = 3.33;                                                                  
   a = a + f;

 warning: conversion to 'char' from 'int' may alter its value [-Wconversion]
    name += age;  
         ^

我们可以看到它确实支持char，因此转换后的值确实被添加到
name
的末尾，它根本没有忽略这个操作。在C++中，与运算符+=，
是不同的运算符。
   int a = 1;                                                                       
   float f = 3.33;                                                                  
   a = a + f;

在这种情况下：

   int a = 1;                                                                       
   float f = 3.33;                                                                  
   a = a + f;

name += age;

可以这样翻译：

   int a = 1;                                                                       
   float f = 3.33;                                                                  
   a = a + f;

name.operator+=(static_cast<char>(age)) ;

name.operator+=（静态施法（年龄））；

如果我们有一个使用运算符+的表达式，没有这样的错误：

   int a = 1;                                                                       
   float f = 3.33;                                                                  
   a = a + f;

name = name + static_cast<char>( age );

name=name+static\u cast（年龄）；

将转化为：

   int a = 1;                                                                       
   float f = 3.33;                                                                  
   a = a + f;

operator+( name, static_cast<char>( age ) ) ;

operator+（姓名、静态演员（年龄））；

在您的示例中，operator+失败的原因已在本文中详细介绍，基本上模板函数不会执行转换，因此需要与const/volatile限定符的可能例外情况完全匹配

   int a = 1;                                                                       
   float f = 3.33;                                                                  
   a = a + f;

更新Wconversion

   int a = 1;                                                                       
   float f = 3.33;                                                                  
   a = a + f;

gcc
有一个带有FAQ的，有点过时，但它确实回答了为什么
-Wall
标志中不包含此检查：

   int a = 1;                                                                       
   float f = 3.33;                                                                  
   a = a + f;

隐式转换在C语言中非常常见。这与前端没有数据流（见下一个问题）这一事实相联系，导致难以避免对完美工作和有效代码的警告。Wconversion是为一种特殊用途而设计的（安全审计，将32位代码移植到64位，等等），程序员愿意接受并解决无效警告。因此，如果未明确请求，则不应启用它

   int a = 1;                                                                       
   float f = 3.33;                                                                  
   a = a + f;

您确定它会忽略连接吗？我得到了
John 7
，这是我所期望的，因为55是
'7'
的ASCII值。此外，您的假设是错误的。对于类类型，
a+=b
并不等同于
a=a+b
。第一个使用
operator+=
，第二个使用
operator+
和
operator=
，这完全取决于类编写器如何实现这些运算符。True。但我知道字符串的+=就像a+b一样工作。是的，它印的是约翰7。我的机器上的年龄是32岁。打字错误现在一切都清楚了。谢谢不损失精度？如果a是int，那将如何发生？似乎.33不能到达第一个接线员。你写的是‘a.operator=（a.+（f.operator int（））’我的意思是警告。更新它。谢谢你指出，a+=b；扩展为a=（a的类型）a+b；在C++中，java是这样做的？@ KodgId假设“代码> A/CODE”是一个STD::string，它将转换为<代码> Acthux+=（b）< /C>。（当然，任何一个好的程序员都会提供这两种语言，如果他提供了一种语言，那么他会提供预期的语义关系。）@KodingKid同样，我认为Java也不会这样定义它。如果我写
somecomplexexpressionwithsideeffects+=“x”
，
somecomplexexpressionwithsideeffects
将不会被计算两次。在Java文档中，[“形式为E1 op=E2的复合赋值表达式相当于E1=（T）（（E1）op（E2）），其中T是E1的类型，但E1只被计算一次。”