类的新手，为什么间接调用下结果就不一样

xiethree

//add成员函数都是调用setcomplexnumber，为什么通过构造函数间接调用setcomplexnumber和直接调用setcomplexnumber结果会不一样

#include <iostream>
#include <cmath>
using namespace std;

class Complex{
public:
    Complex(double =1.0,double=1.0);
    void add(Complex const &);
    void print();
    void setcomplexnumber(double,double);
private:
    double realpart,imaginarypart;
};

Complex::Complex(double re,double im)
{
    setcomplexnumber(re,im);
}

void Complex::add(const Complex &ri)
{
    //setcomplexnumber(realpart+ri.realpart,imaginarypart+ri.imaginarypart); //为什么改成这行可以得到是4和7
    Complex(realpart+ri.realpart,imaginarypart+ri.imaginarypart);   //改成这行变成1和1了
}

void Complex::print()
{
    cout<<"("<<realpart<<","<<imaginarypart<<")";
}

void Complex::setcomplexnumber(double r,double i)
{
    realpart=r;
    imaginarypart=i;
}

int main()
{
    Complex a(4,5);
    Complex b(3,6);
    Complex c;
    a.print();
    cout<<"+";
    b.print();
    cout<<"=";
    c.add(b);
    c.print();
    return 0;
}

tony666

Complex(realpart+ri.realpart,imaginarypart+ri.imaginarypart);   //改成这行变成1和1了
这行并没有改变c 的值啊，他本来就是1,1

xiethree

改了
void Complex::add(const Complex &ri)
{
    //setcomplexnumber(realpart+ri.realpart,imaginarypart+ri.imaginarypart); //为什么改成这行可以得到是4和7
    Complex(realpart+ri.realpart,imaginarypart+ri.imaginarypart);   //改成这行变成1和1了
}
通过调用构造函数间接调用  setcomplexnumber函数向  realpart和 imaginarypart赋值  ，按道理c.print()函数应该输入出  realpart和imaginarypart被改变后的值而不是默认值
你看默认构造函数是间接调用setcomplexnumber函数 ，和直接调用setcomplexnumber作用是一样的，但直接调用setcomplexnumber和通过构造函数间接调用setcomplexnumber值用 c.print()显示时结果是不一样，为什么间接和直接结果会不一样

xiethree

tony666 发表于 2020-7-1 08:54
Complex(realpart+ri.realpart,imaginarypart+ri.imaginarypart);   //改成这行变成1和1了
这行并没有改变 ...

改了

通过调用构造函数间接调用  setcomplexnumber函数向  realpart和 imaginarypart赋值  ，按道理c.print()函数应该输入出  realpart和imaginarypart被改变后的值而不是默认值
你看默认构造函数是间接调用setcomplexnumber函数 ，和直接调用setcomplexnumber作用是一样的，但直接调用setcomplexnumber和通过构造函数间接调用setcomplexnumber值用 c.print()显示时结果是不一样，为什么间接和直接结果会不一样

tony666

不太能理解你说的什么意思，你这个c.add(b)逻辑的问题吧
这是你想要的效果吗？

1. #include <iostream>
   
2. #include <cmath>
   
3. using namespace std;
   
4. 
   
5. class Complex {
   
6. public:
   
7.     Complex(double = 1.0, double = 1.0);
   
8.     void add(Complex const&);
   
9.     void print();
   
10.     void setcomplexnumber(double, double);
    
11. private:
    
12.     double realpart, imaginarypart;
    
13. };
    
14. 
    
15. Complex::Complex(double re, double im)
    
16. {
    
17.     setcomplexnumber(re, im);
    
18. }
    
19. 
    
20. void Complex::add(const Complex& ri)
    
21. {
    
22.     setcomplexnumber(realpart+ri.realpart,imaginarypart+ri.imaginarypart); //为什么改成这行可以得到是4和7
    
23.     //Complex(realpart + ri.realpart, imaginarypart + ri.imaginarypart);   //改成这行变成1和1了
    
24. }
    
25. 
    
26. void Complex::print()
    
27. {
    
28.     cout << "(" << realpart << "," << imaginarypart << ")";
    
29. }
    
30. 
    
31. void Complex::setcomplexnumber(double r, double i)
    
32. {
    
33.     realpart = r;
    
34.     imaginarypart = i;
    
35. }
    
36. 
    
37. int main()
    
38. {
    
39.     Complex a(4, 5);
    
40.     Complex b(3, 6);
    
41.     Complex c(0,0);
    
42.     a.print();
    
43.     cout << "+";
    
44.     b.print();
    
45.     cout << "=";
    
46.     c.add(a);
    
47.     c.add(b);
    
48.     c.print();
    
49.     return 0;
    
50. }

复制代码

JLDawson

1.无名对象，也叫临时对象。指的是直接由构造函数产生，但是没有被任何符号所引用的对象。例如：Complex(realpart+ri.realpart,imaginarypart+ri.imaginarypart);这句话产生的就是一个无名对象，这个对象产生以后，没有什么办法使用它。但是对于Complex a(4,5);来说，则产生的是一个有名字的对象，他的名字就是 a。
在这个基础上我们来看你的代码：
Complex(realpart + ri.realpart, imaginarypart + ri.imaginarypart);//声明了一个无名对象，无名对象在他的构造函数中调用了无名对象的成员函数setcomplexnumber对成员变量进行赋值。无名对象的成员变量分别被修改为4,7。
你的代码理解下来就是：c的add函数中你定义了一个无名对象，并对无名对象的成员变量进行赋值。之后你去打印c的成员变量。期间你对c的成员变量并没有进行修改。

1. #include <iostream>
   
2. #include <cmath>
   
3. using namespace std;
   
4. 
   
5. class Complex {
   
6. public:
   
7.         Complex(double = 1.0, double = 1.0,string sName = "");
   
8.         void add(Complex const&);
   
9.         void print();
   
10.         void setcomplexnumber(double, double);
    
11. 
    
12. private:
    
13.         double realpart, imaginarypart;
    
14.         string sName;
    
15. };
    
16. 
    
17. Complex::Complex(double re, double im, string sName)
    
18.         :sName(sName)
    
19. {
    
20.         setcomplexnumber(re, im);
    
21. 
    
22.         cout << sName.c_str()<< ": " << realpart << imaginarypart << endl;
    
23. }
    
24. 
    
25. void Complex::add(const Complex& ri)
    
26. {
    
27.         //setcomplexnumber(realpart + ri.realpart, imaginarypart + ri.imaginarypart); //为什么改成这行可以得到是4和7
    
28.         Complex(realpart + ri.realpart, imaginarypart + ri.imaginarypart,"noname");   //改成这行变成1和1了
    
29. }
    
30. 
    
31. void Complex::print()
    
32. {
    
33.         cout << "(" << realpart << "," << imaginarypart << ")" << endl;
    
34. }
    
35. 
    
36. void Complex::setcomplexnumber(double r, double i)
    
37. {
    
38.         realpart = r;
    
39.         imaginarypart = i;
    
40. }
    
41. 
    
42. int main()
    
43. {
    
44.         Complex a(4, 5,"a");
    
45.         Complex b(3, 6,"b");
    
46.         Complex c(1,1,"c");
    
47.         a.print();
    
48.         cout << "+" << endl;
    
49.         b.print();
    
50.         cout << "=" << endl;
    
51.         c.add(b);
    
52.         c.print();
    
53.         return 0;
    
54. }

复制代码

输出结果为：

1. a: 45
   
2. b: 36
   
3. c: 11
   
4. (4,5)
   
5. +
   
6. (3,6)
   
7. =
   
8. noname: 47
   
9. (1,1)
   

复制代码

写代码多写几行，多点打印，这样才能更清晰。基础书多看看，最好边看边写代码，互相验证。
（你之前发了几个悬赏提问帖子，我看都有人回复的很明白了。你怎么没有结束提问，并把悬赏发给回答者？）

xiethree

tony666 发表于 2020-7-1 10:55
不太能理解你说的什么意思，你这个c.add(b)逻辑的问题吧
这是你想要的效果吗？

c.add(b)    是把b这个对象用引用方式在c.add这个成员函数中理行加法处理

xiethree

JLDawson 发表于 2020-7-1 11:27
1.无名对象，也叫临时对象。指的是直接由构造函数产生，但是没有被任何符号所引用的对象。例如：Complex(re ...

为什么说这行Complex(realpart + ri.realpart, imaginarypart + ri.imaginarypart,"noname");   会产生临时对象啊，在我看来这个是调用函数，怎么会变成创建临时对象

xiethree

搜索下，懂了，晕，看的书里没写到这个特点，谢谢各位

如果要把这个临时对象值拷出来要怎么操作
void Complex::add(const Complex &ri)
{
    //setcomplexnumber(realpart+ri.realpart,imaginarypart+ri.imaginarypart);
    Complex(realpart+ri.realpart,imaginarypart+ri.imaginarypart);  
}

JLDawson

xiethree 发表于 2020-7-1 16:11
为什么说这行Complex(realpart + ri.realpart, imaginarypart + ri.imaginarypart,"noname");   会产生临 ...

此处的Complex并不是Complex类的构造函数而是Complex类名。
比如int（1），int是内置类型名称，（1）是传参。同理。
Complex是一个自定义类型，他有构造函数 Complex(double = 1.0, double = 1.0);
如何声明定义一个变量（对象），类型名称 对象名称。
以下是构造函数的定义。重点是这句：它会在每次创建类的新对象时执行。

1. 类的构造函数是类的一种特殊的成员函数，它会在每次创建类的新对象时执行。
   
2. 构造函数的名称与类的名称是完全相同的，并且不会返回任何类型，也不会返回 void。构造函数可用于为某些成员变量设置初始值。

复制代码

JLDawson

xiethree 发表于 2020-7-1 17:33
搜索下，懂了，晕，看的书里没写到这个特点，谢谢各位

如果要把这个临时对象值拷出来要怎么操作

你去搜索一下无名对象，然后再考虑自己想要问什么。

xiethree

JLDawson 发表于 2020-7-1 18:57
你去搜索一下无名对象，然后再考虑自己想要问什么。

真不懂，刚学，书没写这个刚开始看类，谢谢你