ASM, C , C++ ...

x86是满递减堆栈还是空递减堆栈？

莫问春秋 — Sat, 14 Jul 2007 15:17:00 GMT

     所谓满递减堆栈是指堆栈通过减小存储器的地址向下增长，堆栈指针指向内含有效数据项的最低地址。空递减堆栈是指堆栈通过减小存储器的地址向下增长，堆栈指针指向堆栈下的第一个空位置。
     那么x86是属于那一种呢？
     结论是x86的堆栈是满递减堆栈。

     我们经常遇到的堆栈操作就是函数调用时需要将函数的参数入栈，因此在调用函数的地方设置一个断点，然后查看汇编代码：

     这里Hello函数有一个默认值为9的参数.

在00401078这行代码执行后停住，然后打开vc的registers可以看到目前esp的值，这是一个内存地址。然后在Memory里面查看esp所值的内存的值，结果是刚好是9.

构造函数调用虚函数追踪

莫问春秋 — Wed, 27 Jun 2007 14:33:00 GMT

好久不写blog都生疏了，刚好公司要组织一次C++的基本功考试,就一个派生类调用虚函数的问题研究了一下编译器的实现：

class A
{
public:
    A(){}
    ~A(){}
     virtual void Display(){cout<<"A"<<endl;}
};

class B:public A
{
public:
    B(){Display();}
    ~B(){}
    virtual void Display(){cout<<"B"<<endl;}
};
int main()
{
   B *pBb = new B;
   delete pBb;
}

在B(){Display();}设定一个断点，跟踪到汇编代码得到如下代码：
00401391   mov         eax,dword ptr [ebp-10h]
00401394   mov         dword ptr [eax],offset B::`vftable' (00432020)
0040139A   mov         ecx,dword ptr [ebp-10h]
0040139D   call        @ILT+155(B::Display) (004010a0)
前三排的代码是设置虚函数表，然后直接调用了B::Display函数，并没有通过虚函数表间接调用这个函数。这说明在构造函数中虽然虚函数表已经设置好了，但是调用虚函数是不会使用虚函数表的，是直接调用.

下面的代码是非构造函数内经过虚函数表间接调用Display的汇编码：
0040127E   mov         edx,dword ptr [ebp-10h]
00401281   mov         eax,dword ptr [edx]
00401283   mov         esi,esp
00401285   mov         ecx,dword ptr [ebp-10h]
00401288   call        dword ptr [eax]

[转贴]总结一下C++的名称查找顺序 from cppblog.com/shifan3

莫问春秋 — Fri, 29 Dec 2006 02:44:00 GMT

1。符号查找（对于函数此时只看名字，不看参数）
    大致顺序是
    (1)如果有限定名( XXX:: )那么就直接在XXX里查找
    (2)函数局部名字空间
    (3)(如果是成员)类名字空间
    (4)递归向上至所有基类的名字空间
    (5)当前名字空间
    (6)递归向外至所有外层名字空间,
    在任一层里, 用using导入的符号和该层的其他符号同一对待。
    keonig查找: 对于函数, 如果参数为类/结构/模版类并位于其他的名字空间,
    在(5)和(6)的查找中导入该空间(不递归向外)的符号一同查找.

2。（如果是函数）重载决议（注意此时特化的函数不参与决议）

3。（如果是类内部的名字）检查访问权（注意此时特化的函数仍然不参与决议）

4。（如果找到了一个模版）模版特化决议

编译器执行以上步骤的时候是使用贪心匹配，只要找到一个符合当前检查内容的就会停止查
找
所以任何一层都有可能发生错误的掩盖情况

例1

1 void f( int ) {}
2 class Y
3 {
4 public :
5      void f() {}
6     Y()
7      {
8         f( 1 );
9     }
10 } ;

这里的f(2)在1.(2)这里找到了符号f，就不会向上到1.(5)查找到真正的f(int)了

例2

void g( int ) {}
namespace S
{
     void g() {}

     void h()
     {
        g( 1 );
    }
}

这里的g(1)在1.(5)这里找到了符号g，就不会向上到1.(6)查找到真正的g(int)了

例3

class Y
{
     void f( int ) {} // [1]
public :
     void f( double ) {} // [2]
} ;

int main()
{
    Y y;
    y.f( 1 );
}

y.f(1)会调用[2]吗？不会，因为在第2步重载决议的时候就选定[1]了，因此这段代码会报
出无法访问private成员的错误

例4

template < typename T >
void f(T) {} // [1]

template < typename T >
void f(T * ) {} // [2]

template <>
void f < int *> ( int * ) {} // [3]

int main()
{
int * p = 0 ;
f(p);
}

这里的f(p)会调用[3]吗？
不会，因为在进行到第二步重载决议的时候，只有[1]和[2]参与了重载决议，结果选择了
[2]，那么[1]的特化版本[3]当然就轮不到了。

例5

class X
{
    template < typename T > void g() {}
public :
    template <> void g < int > () {}
} ;

int main()
{
    X y;
    y.g < int > ();
}

这里首先第3步访问检查发现g为private（此时g的特化版本被直接无视了），所以即使
g<int>为public, 该段代码仍然不能够编译通过

例6

namespace E
{
     class X {} ;
     void f(X) {} // [1]
}

void f(E::X) {}    // [2]

class X
{
public :
     void f() {} // [3]
     void g()
     {
        E::X x;
        f(x); // [4]
    }
} ;

[4]会调用那个呢? 在1.(3)里就确定了是[3],因此参数不匹配
如果注释掉[3]的f,那么由于koenig查找, 在1.(5)里[1]和[2]都会是平等的可选项
所以会出现二义性.
如果把namespace E改为class E, 把E中的f改为静态函数
由于koenig查找仅仅导入参数的名字空间, 因此[1]将不参与1.(5)的查找,
最终结果会是[2]

关于operator=的一点疑问？

莫问春秋 — Fri, 11 Aug 2006 06:34:00 GMT

An assignment operator shall be implemented by a non-static member function with exactly one parameter.Because a copy assignment operator operator= is implicitly declared for a class if not declared by the user ,a base class assignment operator is always hidden by the copy assignment operator of the derived class.
--- 摘自 [ANSI-C++ 1998 Standard]

下面有一段代码：

class Base
{
public:
    void operator =(const Base & right)
    {
        cout<<"Base's  operator ="<<endl;
    }
};

class Derd:public Base
{
public:
    void operator =(const Base & right)
    {
        cout<<"Derd's operator ="<<endl;
    }

};

int main(int argc, char* argv[])
{
    Derd lDerd;
    Derd rDerd;
    lDerd = rDerd;
    return 0;
}

这段代码的结果是：
Base's operator =
按照C++标准的说明，基类的operator =应该被hidden了，可是这里为什么还是这个结果？察看汇编代码发现，实际上Base的operator=间接的在派生类的implicitly-declared Derd::operator=中被调用。问题就来了，我明明已经在派生类中自己声明了一个operator=的啊！我翻看了一些资料，都说在你自己不声明任何复制赋值操作符的时候，编译器会为你隐式生成一个，可是这儿我已经声明了一个，为什么编译器还要声明复制赋值操作符？
在几位兄台的提点下，我仔细了搜索了下C++标准，查找了相关内容。我的错误大概是我没搞清楚复制赋值操作符的声明形式，A user-declared copy assignment operator X::operator= is a non-static non-template member function of class X with exactly one parameter of type X, X&, const X&, volatile X& or const volatile X&。从这一点来看，void operator =(const Base & right)根本不是Derd的复制赋值操作符，所以编译器隐式声明了一个void operator =(const Derd & right)。请大家在帮我分析下这个结论有问题不。

C++多态居然可以这样用?

莫问春秋 — Wed, 02 Aug 2006 03:30:00 GMT

用代码说话吧。
如下：

class B
{
public:
virtual int Comment(int v)
{val = v;cout<<"Base"<<endl;return v;};
protected:
int val;
};
class D : public B
{
int Comment (int v)
{val = v;cout<<"Drived"<<endl;return v;};
private:
int val;
};
int main(int argc, char* argv[])
{
B* bptr = new D;
bptr->Comment(99) ; // 标准多态行为
(*bptr).Comment(99); // 这样也是多态？从结果来看，的确是
system("pause");
return 0;
}

bptr->Comment(99)这种用->应该是最典型的多态调用的方式，(*bptr).Comment(99)这种首先用*解引用指针然后用.来调用函数既然也能够多态，这大大改变了我以前的认知，甚至我现在还很怀疑这个结论成立否？不过在汇编成面上，他们的代码是一样的，这个证据让我还是很相信这个结论的正确性的。如果我的这份结论是错误的，请大家指出！

C++ 备忘录 (一)

莫问春秋 — Sat, 11 Feb 2006 04:07:00 GMT

目录：
１、成员函数的重载、覆盖与隐藏？
２、用户自定义类型转换的方法？
３、声明的定义的区别?
４、类模板的使用方法总结？
5、const的修饰问题？

成员函数的重载、覆盖与隐藏?
--摘自《高质量C++/C 编程指南》

成员函数被“重载”的特征：
（1）相同的范围（在同一个类中）；
（2）函数名字相同；
（3）参数不同；
（4）virtual 关键字可有可无。

“覆盖”是指派生类函数覆盖基类函数，特征是：
（1）不同的范围（分别位于派生类与基类）；
（2）函数名字相同；
（3）参数相同；
（4）基类函数必须有virtual 关键字。

“隐藏”规则的特征是：
（1）如果派生类的函数与基类的函数同名，但是参数不同。此时，不论有无virtual
关键字，基类的函数将被隐藏（注意别与重载混淆）。
（2）如果派生类的函数与基类的函数同名，并且参数也相同，但是基类函数没有virtual
关键字。此时，基类的函数被隐藏（注意别与覆盖混淆）。

用户自定义类型转换的方法？

首先应该明白什么是“隐式转换”和“强制转换”？

　前者是指：在算数运算和关系运算中如果参与运算的操作数类型不一致，则系统自动对数据进行转换，转换的原则是将低类型数据转换为高类型数据。这种转换过程中数据的精度没有损失，但是在赋值运算中，则要求一例将右值类型转换为左值类型，这存在精度损失。

　　后者是指：强制转换往往是显式的转换，这种转换是暂时性的，一次性的。

　　在用户定义的转换中，如果要把一个类对象隐式转换成其他类型的对象，使用转换函数，形式如下：　

　　　Operator type();

这里的type 可用内置类型类类型或typedef 名取代，但是不允许type 表示数组或函数。

类型转换函数必须是成员函数它的声明不能指定返回类型和参数表.

凡是只有一个参数的类的构造函数，每一个函数都定义了一个隐式转换。可以使用explicit来告诉编译器不要使用那个显式构造函数来执行隐式类型转换。

　　　用户定义的转换是由转换函数或构造函数执行的。正如前面已经看到的在转换函

数执行转换之后接着可以有一个“标准转换”把转换函数的结果转换成最终的目标类型。类似地，构造函数执行转换之前也可以有一个“标准转换”把要被转换的值变成构造函数参数的类型。这里“标准转换”指系统内置的转换。

声明和定义的区别？

声明：一种把一个名称引入或者重新引入到某个C++作用域的构造。
定义：它也是一种声明，但该声明必须给出被声明实体的细节。对于变量而言，这里的细节是指：为被声明实体保留存储空间。对于class类型和函数定义而言，指的是包含有一队花括号内容的声明。对于外部变量而言，指的是前面没有关键字extern或者在声明时就进行初始化。

变量的声明有两种情况：
    一种是需要建立存储空间的。例如：int a 在声明的时候就已经建立了存储空间。
    另一种是不需要建立存储空间的例如：extern int a 其中变量a是在别的文件中定义的.前者是"定义性声明 (defining declaration)"或者称为"定义(definition)",而后者是"引用性声明 (referncing declaration)" 从广义的角度来讲声明中包含着定义，但是并非所有的声明都是定义，例如：int a 它既是声明，同时又是定义。然而对于 extern a 来讲它只是声明不是定义。一般的情况下我们常常这样叙述，把建立空间的声明称之为"定义"，而把不需要建立存储空间称之为"声明"。很明显我们在这里指的生命是范围比较窄的，也就是说非定义性质的声明.    --摘自erictb的blog

    编译器总是对每一个cpp文件分别进行编译，这就是为什么debug文件夹下来总是存在多个obj文件。编译器必须知道被编译的cpp文件内的所有“类型信息”，所以我们总是经常include别的头文件，然后链接器会正确链接obj文件。
    C++里的函数声明“隐式”表达该函数会在别个地方定义。如果在函数前面加一个extern的话，就变成显式声明了。在变量前面使用extern的话，只是声明一个对象，而不分配内存。详细参看《C+primer》331页。
    另外，extern “c”加在函数前面表示函数是用C语言写的函数，不过他只能够压制nonmember function的“mangling”效果。同时，变量前面的extern “c”也只是表示声明。

类模板的使用方法总结？

模板参数可以是一个模板类型参数也可以是一个模板非类型参数（它代表了一个常量表达式）。

显式实例声明：

在定义了模版类后，可以用template class Queue<int>显式实例声明。也可以使用template特化整个模版类或者某一个特化函数。甚至可以特化模版参数的某一个，template <int hi, int wid>class Screen

{}改写成template <int hi>class Screen<hi, 80>{}

模板有两种编译模式：“包含编译模式”和“分离编译模式”。前者要求将模板的定义放在一个头文件中，也提供一个cpp文件来包含这个头文件，这样编译器才能编译模版定义。

const的修饰问题？
类似const int* & rp、const int *、int * const这样的语句，const在其中到底修饰谁？

根据C++98标准8.3.2对引用的定义：
对于声明：
    T D;
  如果D具有如下形式：
    & D1         //注意，&与D1之间不能有任何cv修饰符
那么标识符D1的类型为“reference to T”。
对于“const int* & rp”套用上面的格式，则：
         T                      D;
   const int*              &rp;
这样，D就具有了&D1的形式，其中D1为rp。而T，则是const int*。
则
const int * & 表示：“a non-const reference to T where T is a pointer to 'const int' ”。
const int *表示：“pointer to 'const int'”。
int * const表示：“const pointer to int”。

对于引用，还有一个很重要的原则：
const 常量引用(reference to const T)可以用不同类型的对象初始化，只要能从一种类型转换到另一种类型即可，也可以是不可寻址的值如文字常量。
包括两种常见的方式：

double dval = 3.14159; const int &ir = 1024;
const int ival = 1024;   const int * const &pi_ref = &ival; //需要常量指针