代码的函数部分看不懂

巨兔12138

1. #include<iostream>
   
2. class Complex   //complex表示“复数”
   
3. {
   
4. public:
   
5.         Complex();
   
6.         Complex(double r,double i);
   
7.         Complex complex_add(Complex &d);
   
8.         void print();
   
9. private:
   
10.         double real;
    
11.         double imag;
    
12. }；
    
13. Complex::Complex()
    
14. {
    
15.         real = 0;
    
16.         imag = 0;
    
17. }
    
18. Complex::Complex(double r,double i)
    
19. {
    
20.         real = r;
    
21.         imag = i;
    
22. }
    
23. Complex Complex::complex_add(Complex &d)
    
24. {
    
25.         Complex c;
    
26.         c.real = real + d.real;
    
27.         c.imag = imag + d.imag;
    
28.         return c;
    
29. }
    
30. void Complex::print()
    
31. {
    
32.         std::cout<<”(”<<real<<”,”<<imag<<”i)\n”;
    
33. }
    
34. int main()
    
35. {
    
36.         Complex c1(3,4),c2(5,-10),c3;
    
37.         c3 = c1.complex_add(c2);
    
38.         std::cout<<”c1=”;
    
39.         c1.print();
    
40.         std::cout<<”c2=”;
    
41.         c1.print();
    
42.         std::cout<<”c1+c2=”;
    
43.         c3.print();
    
44.         return 0;
    
45. }
    

复制代码

哪位大神能给解释一下Complex Complex::complex_add(Complex &d)部分的函数是什么意思啊
不要说是是现实“是不遇事不相加虚部与虚部相加”
我知道是这个作用，我是不知道为什么会实现这个功能
谢谢啦！！！

人造人

我是不知道你想知道什么
还有，你问题中的错别字太多，也许是这个问题导致的？

巨兔12138

人造人 发表于 2020-3-31 19:06
我是不知道你想知道什么
还有，你问题中的错别字太多，也许是这个问题导致的？

就是我知道函数体的作用是，实部与实部相加，虚部与虚部相加
但是我不知道是如何实现这个功能的
就是能给解释下main函数的实现过程吗

人造人

巨兔12138 发表于 2020-3-31 19:24
就是我知道函数体的作用是，实部与实部相加，虚部与虚部相加
但是我不知道是如何实现这个功能的
就是能 ...

还是看不懂你的问题

对于这个问题 “但是我不知道是如何实现这个功能的”
不就是这样实现的吗？ 实部与实部相加，虚部与虚部相加
你想知道什么？

巨兔12138

人造人 发表于 2020-3-31 19:47
还是看不懂你的问题

对于这个问题 “但是我不知道是如何实现这个功能的”

1. #include<iostream>
   
2. class ClxBase
   
3. {
   
4. public:
   
5.         ClxBase()
   
6.         {
   
7. };
   
8. virtual ~ClxBase()
   
9. {
   
10. };
    
11. virtual void doSomething()
    
12. {
    
13.         std::cout<<”Do something in class ClxBase\n”
    
14. }
    
15. };
    
16. class ClxDerived:public ClxBase
    
17. {
    
18. public:
    
19.         ClxDerived()
    
20.         {
    
21. };
    
22. ~ClxDerived()
    
23. {
    
24.         std::cout<<”Output from the destructor of class ClxDerived\n”;
    
25. };
    
26. void doSomething()
    
27. {
    
28.         std::cout<< ”Do something in class ClxDerived\n”;
    
29. };
    
30. };
    
31. int main()
    
32. {
    
33.         ClxBase*pTest = new ClxDerived;
    
34. }
    

复制代码

就比如我想知道这个代码main函数的实现过程
我就会这样解释

main函数中，在基类ClxBase中定义了一个指针pTest指向子类ClxDerived，所以运行代码时，先执行子类ClxDerived的doSomething方法输出Do something in class ClxDerived，然后析构器清理内存，执行析构器代码输出Output from the destructor of class ClxDerived

这就是实现过程啊...我的问题真的那么难理解吗...

人造人

我知道x是什么，但是我想知道x是什么

你的这个问题给我的就是这种感觉

人造人

巨兔12138 发表于 2020-3-31 19:50
就比如我想知道这个代码main函数的实现过程
我就会这样解释

这样不就好了，是你之前提的问题不好
我知道你想知道什么了，大概
我想想看该怎么回答这个问题

巨兔12138

人造人 发表于 2020-3-31 19:56
这样不就好了，是你之前提的问题不好
我知道你想知道什么了，大概
我想想看该怎么回答这个问题

好，谢谢

人造人

我不知道这是不是你想要的

1. #include <iostream>
   
2. 
   
3. class Complex   //complex表示“复数”
   
4. {
   
5. public:
   
6.         Complex();
   
7.         Complex(double r,double i);
   
8.         Complex complex_add(Complex &d);
   
9.         void print();
   
10. private:
    
11.         double real;
    
12.         double imag;
    
13. //}； // 这里你还用了中文的分号？
    
14. };
    
15. Complex::Complex()
    
16. {
    
17.         std::cout << "Complex::Complex()" << std::endl;
    
18.         real = 0;
    
19.         imag = 0;
    
20. }
    
21. Complex::Complex(double r,double i)
    
22. {
    
23.         std::cout << "Complex::Complex(double r,double i)" << std::endl;
    
24.         std::cout << "r=" << r << ",i=" << i << std::endl;
    
25.         real = r;
    
26.         imag = i;
    
27. }
    
28. Complex Complex::complex_add(Complex &d)
    
29. {
    
30.         std::cout << "Complex Complex::complex_add(Complex &d)" << std::endl;
    
31.         Complex c;
    
32.         c.real = real + d.real;
    
33.         c.imag = imag + d.imag;
    
34.         return c;
    
35. }
    
36. void Complex::print()
    
37. {
    
38.         //std::cout<<”(”<<real<<”,”<<imag<<”i)\n”;      // 这个双引号比较奇怪
    
39.         std::cout << "(" << real << "," << imag << "i)\n";
    
40. }
    
41. int main()
    
42. {
    
43.         Complex c1(3,4),c2(5,-10),c3;
    
44.         c3 = c1.complex_add(c2);
    
45.         return 0;
    
46. }
    

复制代码

1. $ ./main
   
2. Complex::Complex(double r,double i)
   
3. r=3,i=4
   
4. Complex::Complex(double r,double i)
   
5. r=5,i=-10
   
6. Complex::Complex()
   
7. Complex Complex::complex_add(Complex &d)
   
8. Complex::Complex()
   

复制代码

这个是43行创建c1对象的时候输出的

1. Complex::Complex(double r,double i)
   
2. r=3,i=4
   

复制代码

这个是创建c2对象

1. Complex::Complex(double r,double i)
   
2. r=5,i=-10
   

复制代码

接下来的这个是创建c3对象，使用的是默认构造函数

1. Complex::Complex()

复制代码

输出这个，说明执行完了30行

1. Complex Complex::complex_add(Complex &d)

复制代码

最后这个是第31行创建对象c的时候输出的

1. Complex::Complex()

复制代码

4goodworld

1. Complex Complex::complex_add(Complex &d)

复制代码

这个 Complex &d是引用 ，相当于传递一个 complex类型的 参数（或者叫做值）
对于 c3 = c1.complex_add(c2);而言
它巧妙地解决了c1+c2的问题
你定义了
Complex c1(3,4),c2(5,-10),c3;
那么对于c1而言，
real = 3;
imag =4;
明确了
然后你又
c1.complex_add(c2);
不就是要对下面的内容进行操作

        Complex c;//这个局部变量，不去管
        c.real = real + d.real; //real =3，d.real等于c2.real，c2.real不就等于5 ，结果为8
        c.imag = imag + d.imag;//同理 4-10=-6
        return c;
最后的结果，应该是 8，-6