堆栈是个什么鬼东西？ 重载呢？

OwnWaterloo

heap —— 堆
stack —— 栈

堆栈是个什么鬼东西？


overload —— 重载
override —— 覆盖
hide —— 隐藏
replace —— 替换

是哪从半调子开始把上面的东西统统叫做重载的？

OwnWaterloo

区别：

1. replace

C++提供默认的 void* operator new (size_t s);
你写了一个自己的版本， 这叫replace。

2. overload

1. 
   
2. int max(int a, int b);
   
3. double max(double a, double b);
   

复制代码

具有相同的名字， 但参数不同的函数之间互为overloaded。

根据调用处的实际参数， 决定实际调用的函数：

1. 
   
2. max(1212, 326);   // int max(int,int);
   
3. max(12.12, 3.26); // double max(double, double);
   

复制代码

3. hide

上述"相同名字"有一个前提： 在一个查找的作用域内。

1. 
   
2. namespace base
   
3. {
   
4.       int max(int a, int b);
   
5. }
   
6. 
   
7. namespace derived
   
8. {
   
9.       double max(double a, double b);
   
10. }
    
11. 
    
12. void test1()
    
13. {
    
14.       using base::max;
    
15.       max(12.12, 3.26); // int max(int, int);
    
16. // 在这个作用域里只有一个max
    
17. // 就是int max(int, int);
    
18. // 即使调用的实际参数是 double, double， 也只能选中这个（通过double->int的转换）
    
19. // 不会选到derived::max
    
20. }
    
21. 
    
22. void test2()
    
23. {
    
24.       using derived::max;
    
25.       max(1212, 326); // double max(double, double);
    
26. // 同上， 不会选到base::max
    
27. }
    

复制代码

那么：

1. 
   
2. struct B
   
3. {
   
4.       void f();
   
5. };
   
6. 
   
7. struct D : B
   
8. {
   
9.       void f(int );
   
10. };
    
11. 
    
12. D d;      // D确实通过继承得到B::f();
    
13. d.f();    // 只是这个作用域里的f只有 D::f(int)， 没有 B::f()。
    
14. d.B::f(); // 显示调用通过继承得到的B::f();
    

复制代码

这叫hide， 派生类中的名字会隐藏基类中的名字。
使得基类的名字没有参与重载的资格。

与上面名字空间的例子类似， 可以通过using 引入基类的名字。

1. 
   
2. struct D1 : B
   
3. {
   
4.       void f(double);
   
5.       using B::f;
   
6. }
   
7. 
   
8. D1 d;
   
9. d.f( ... ); // 在这里， 重载候选就有 D1::f与B::f， 根据实际参数来决议
   

复制代码

4. override

通过基类指针或者引用操作某个派生对象， 调用某个虚函数。
派生类可通过override， 使得该虚函数调用派生类中的版本， 而非基类中的版本。

override和overload是完全不相干的关系。
overload是编译时概念， override是运行时概念。

1. 
   
2. struct B
   
3. {
   
4.       virtual ~B();
   
5.       virtual void f(int );
   
6.       virtual void f(double);
   
7. };
   
8. 
   
9. void test(B* b)
   
10. {
    
11. // 这两个调用是由overload决议
    
12. // 代码一旦编译完成， 就固定死了， 没得更改。
    
13.       b->f(1212);  // B::f(int);
    
14.       b->f(3.26);  // B::f(double);
    
15.       delete b;
    
16. }
    

复制代码

运行时可以通过传入不同的B的派生类， 影响test的最终行为。

1. 
   
2. struct D1 : B {};
   
3. test(new D1);
   
4. // D1没有override任何虚函数， 所以上面两个调用最终是B::f(int)和B::f(double)
   

复制代码

1. 
   
2. struct D2 : B
   
3. {
   
4.       void f(int );
   
5. };
   
6. test(new D2);
   
7. // D2有override一个： B::f(int)， 所以， 最终调用是 D2::f(int), B::f(double);
   

复制代码

如此等等。

再解释一下运行时。
上面的代码编译、链接完毕后， test的行为不能通过overload修改， 但可以通过override修改：

1. 
   
2. #include <stdio.h>
   
3. #include <string.h>
   
4. 
   
5. int main(int argc, char* argv[])
   
6. {
   
7.       char const* name = "D1";
   
8.       if (argc>1) name = argv[1];
   
9.       B* b = 0;
   
10.       if (strcmp(name, "D1")==0) b = new D1;
    
11.       else if (strcmp(name, "D2")==0) b = new D2;
    
12.       ...
    
13.       else
    
14.       {
    
15.             fprintf(sterr,"no derived class named %s", name);
    
16.             return -1;
    
17.       }
    
18.       test(b);
    
19.       return 0;
    
20. }
    

复制代码

gcc xxx.cpp -o a.out  编译完毕后， a.out的行为依然可以修改：
a.out D1
a.out D2



大哥们， 中文很乱， 学点E文好不？

ecjtubaowp

堆栈应该就是栈。

OwnWaterloo

插了2、3楼的， 你们{:3_204:}

liwangli1983

插了2、3楼的， 你们
OwnWaterloo 发表于 2010-10-21 16:43

    这个论坛不能自主删帖啊......才发现

davelv

回复 7# liwangli1983


谁说不能～～

OwnWaterloo

ls两位， 您们是好人{:3_201:}

davelv

ls两位， 您们是好人
OwnWaterloo 发表于 2010-10-21 16:50

这不是传说中的好人卡么？又收到一张！看来不只是女同胞们会送我，连男同志也是阿.

pmerofc

“堆栈”的确是被用得非常似是而非的一个词

概念不清是通病

liwangli1983

回复  liwangli1983


谁说不能～～
davelv 发表于 2010-10-21 16:49

        我光往左边看了。。。原来在右边