欧美一级专区,国语自产精品视频在线看,亚洲欧洲日本一区二区三区

WordFeatureLib�~�程�W�记

inwind — Thu, 16 Mar 2006 10:45:00 GMT

一、小心内存分配，明确每个变量的存储位�|?BR>二、算法设计，在尽可能外的循环内执行耗时多的指��o(h��)
三、小心成员变量的引用传递，防止对内存的多次释放

��M��Q�注意算法设计，��心内存分配。需要加�?/P>

inwind 2006-03-16 18:45 发表评论

数组和指针的比较

inwind — Thu, 22 Dec 2005 05:42:00 GMT

1。定义数�l�变量时必须指定数组元素个数�Q�因为系�l�会(x��)�Ҏ(gu��)��元素个数在编译时一�ơ性分配这么多内存�Q?BR> 而指针变量只需要指定类型，�pȝ��只�ؓ(f��)该指针变量分�?字节�Q?2位机�Q�内存，而不�?x��)��?f��)该变量所指内容分配内存�?BR>
2。指针变量是有存储空间的�Q�而数�l�名仅仅是一个标��P��没有实际存储�I�间�Q�单单一个数�l�名��只能表�C��数组的第1个元素的地址。int a[10]; 规定&a��q��?amp;a[0]或者a .

3。例�?char str[]= "hello world"和char *p = "hello world"中，数组str是先分配�l�他元素个数个内存，然后��后面的字符串复制给�q�个�I�间�Q�注意，此时应该考虑\0字符�Q�；而p的徏立过�E�是先在静态存储区建立常字�W�串"hello world\0"�Q�然后将p指向�q�个常字�W�串。所以数�l�str中元素的内容可以通过重新赋值改变，而p指向的内容不能改变�?img src ="http://m.shnenglu.com/inwind/aggbug/1958.html" width = "1" height = "1" />

inwind 2005-12-22 13:42 发表评论

C/C+语言struct深层探烦 (转自CSDN)

inwind — Wed, 14 Dec 2005 10:27:00 GMT

摘要: 1. struct的巨大作用　　面对一个�h的大型C/C++�E�序�Ӟ��只看其对struct的��用情冉|��们就可以对其�~�写者的�~�程�l�验�q�行评估。因��Z��个大型的C/C++�E�序�Q�势必要涉及一�?甚至大量)�q�行数据�l�合的结构体�Q�这些结构体可以��原本意义属于一个整体的数据�l�合在一赗��从某种�E�度上来��_(d��)��?x��)不会(x��)用struct�Q�怎样用struct是区别一个开发�h员是否具备丰富开发经历的标志。　　在网�l�协议、通信控制、嵌... 阅读全文

inwind 2005-12-14 18:27 发表评论

vc6函数调用��析

inwind — Wed, 14 Dec 2005 10:26:00 GMT

今天研究了一下vc6函数调用�Q�看看vc6调用函数时候都做了什么。有些意思�?BR>
我写下了如下代码�Q?BR>

int fun(int a,int b)
{
    int i = 3;
    return a+b+i;
}

int main()
{
    int a = 1,b=2;
    int result ;
    result = fun(1,2);
    return result;
}

非常��单。反汇编�?Debug�?变成�q�样

1:    int fun(int a,int b)
2:    {
00401020   push        ebp
00401021   mov         ebp,esp
00401023   sub         esp,44h
00401026   push        ebx
00401027   push        esi
00401028   push        edi
00401029   lea         edi,[ebp-44h]
0040102C   mov         ecx,11h
00401031   mov         eax,0CCCCCCCCh
00401036   rep stos    dword ptr [edi]
3:        int i = 3;
00401038   mov         dword ptr [ebp-4],3
4:        return a+b+i;
0040103F   mov         eax,dword ptr [ebp+8]
00401042   add         eax,dword ptr [ebp+0Ch]
00401045   add         eax,dword ptr [ebp-4]
5:    }
00401048   pop         edi
00401049   pop         esi
0040104A   pop         ebx
0040104B   mov         esp,ebp
0040104D   pop         ebp
0040104E   ret

7:    int main()
8:    {
00401060   push        ebp
00401061   mov         ebp,esp
00401063   sub         esp,4Ch
00401066   push        ebx
00401067   push        esi
00401068   push        edi
00401069   lea         edi,[ebp-4Ch]
0040106C   mov         ecx,13h
00401071   mov         eax,0CCCCCCCCh
00401076   rep stos    dword ptr [edi]
9:        int a = 1,b=2;
00401078   mov         dword ptr [ebp-4],1
0040107F   mov         dword ptr [ebp-8],2
10:       int result ;
11:       result = fun(1,2);
00401086   push        2
00401088   push        1
0040108A   call        @ILT+5(fun) (0040100a)
0040108F   add         esp,8
00401092   mov         dword ptr [ebp-0Ch],eax
12:       return result;
00401095   mov         eax,dword ptr [ebp-0Ch]
13:   }
00401098   pop         edi
00401099   pop         esi
0040109A   pop         ebx
0040109B   add         esp,4Ch
0040109E   cmp         ebp,esp
004010A0   call        __chkesp (004010c0)
004010A5   mov         esp,ebp
004010A7   pop         ebp
004010A8   ret

我们主要来看看函数调用部�?BR>
1.参数压栈
push 2
push 1
参数从右向左压栈(__cdcel),esp递减

2.调用函数
call        @ILT+5(fun) (0040100a)
�q�条指��o(h��)�?x��)把下一行代码的地址压栈�Q�也��是函数�q�回地址。同时蟩转到函数入口�?BR>
3.�q�入函数�?/STRONG>
push        ebp
mov         ebp,esp
首先保存ebp的地址�Q�然后把esp保存到ebp中去
00401023   sub         esp,44h
00401026   push        ebx
00401027   push        esi
00401028   push        edi
减小stack的指�?注意�Q�stack是从内存的高端向低端生长�?�Q��ؓ(f��)局部变量保留一些空��_(d��)��q�里�?4h不是固定的，��q��译器计算得来
00401029   lea         edi,[ebp-44h]
0040102C   mov         ecx,11h
00401031   mov         eax,0CCCCCCCCh
00401036   rep stos    dword ptr [edi]
�?xCC填充局部变量空间。这是Debug模式�Ҏ(gu��)��的，如果是字�W�串�Q�你��q��到被初始化成"烫烫烫烫烫烫"
��x��Q�整个堆栈变�?BR>|-----------------|
|    局部变�?   |
|-----------------|
|    局部变�?    |<----ebp-4
|-----------------|
|    old ebp          |<----ebp
|-----------------|
| 函数�q�回地址| <----ebp+4
|-----------------|
|      参数1        | <----ebp+8
|-----------------|
|      参数2         |
|-----------------|

Next:
int i = 3;
00401038   mov         dword ptr [ebp-4],3
�q�里你看到[ebp-4]��是�W�一个局部变量i�?BR>0040103F   mov         eax,dword ptr [ebp+8]
00401042   add         eax,dword ptr [ebp+0Ch]
00401045   add         eax,dword ptr [ebp-4]
[ebp+8],[ebp+0Ch]分别是a和b�?BR>
4.函数�q�回
函数的结果都是放在eax�?ps:你可以在vc的watch�H�口输入@EAX�Q�就可以直接看到函数�q�回��g��Q?BR>00401048   pop         edi
00401049   pop         esi
0040104A   pop         ebx
0040104B   mov         esp,ebp
0040104D   pop         ebp
0040104E   ret
把edi,esi,ebx恢复�Q�然后恢复esp,ebp,�q�时函数的返回地址��在栈顶�Q�调用ret��可以返回了�?BR>

那如果改变函数的�q�回地址�?x��)怎样�Q?BR>ok,我们修改一下代码：(x��)

#include <stdio.h>
void fun2()
{
    printf("fun2() called");
}

int fun(int a,int b)
{
    int i = 3;
    printf("return address:0x%x\n",&i+2);
    printf("fun2 address:0x%x\n",&fun2);
    /*int *p = (int*)&fun2;
    __asm
    {
        mov ebx,p
        mov dword ptr[ebp+4],ebx
    }*/
    *(&i+2)=(int)&fun2; //modify return address
    return a+b+i;
}

int main()
{
    int a = 1,b=2;
    int result ;
    result = fun(1,2);
    return result;
}

Wow,�q�时�Q�我们就�?x��)发现fun2被调用了。这��是Buffer overrun(�~�冲溢出)所做的事情吧�?BR>

5.最后一步，调用者调整堆栈指�?/STRONG>
call        @ILT+5(fun) (0040100a)
add         esp,8
��Z��么要调整呢，因�ؓ(f��)调用之前push两个参数�q�入栈，现在要恢复它
mov         dword ptr [ebp-0Ch],eax
�q�句话就是��n用函数调用的果实�?EAX保存了函数的�q�回�?

inwind 2005-12-14 18:26 发表评论

函数对象

inwind — Wed, 14 Dec 2005 10:24:00 GMT

函数指针的一�U�替代策略是Function object�Q�函数对象）�?/P>
函数对象与函数指针相比较有两个方面的优点�Q�首先如果被重蝲的调用操作符是inline函数则编译器能够执行内联�~�译�Q�提供可能的性能好处�Q�其�ơ函数对象可以拥有�Q意数目的额外数据�Q�用�q�些数据可以�~�冲�l�果�Q�也可以�~�冲有助于当前操作的数据�?/P>
函数对象是一个类�Q�它重蝲了函数调用操作符operator() ,该操作符��装了一个函数的功能。典型情况下函数对象被作为实参传递给泛型��法�Q�当然我们也可以定义独立的函数对象实例�?/P>
来看下面的二个例子：(x��) 比较理解�?x��)更好些�Q?/P>
#include
#include
#include
#include
using namespace std;
class Sum {
int val;
public:
Sum(int i) :val(i) { }

//当在需要int的地方，Sum��自动�{换�ؓ(f��)int�c�d��
//�q�里是�ؓ(f��)了方便cout<operator int() const { return val; }

//写在�c�M��的函��C��码一般默认�ؓ(f��)内联代码
int operator()(int i) { return val+=i; }
};

void f(vector v)
{
Sum s = 0; //Sum s = 0�{��h(hu��n)于Sum s(0),不等价于Sum s;s = 0;

//对vector中的元素求和
//函数对象被作为实参传递给泛型��法
s = for_each(v.begin(), v.end(), s);

cout << "the sum is " << s << "\n";

//更简单的写法�Q�定义独立的函数对象实例
cout << "the sum is " << for_each(v.begin(), v.end(), Sum(0)) << "\n";
}

int main()
{
vector v;
v.push_back(3); v.push_back(2); v.push_back(1);
f(v);
system("pause");
return 0;
}
�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q?BR>#include
#include
#include
#include "print.hpp"
using namespace std;

// function object that adds the value with which it is initialized
class AddValue {
private:
    int theValue;    // the value to add
public:
    // constructor initializes the value to add
    AddValue(int v) : theValue(v) {
    }

    // the ``function call'' for the element adds the value
    void operator() (int& elem) const {
        elem += theValue;
    }
};

int main()
{
    list coll;

    // insert elements from 1 to 9
    for (int i=1; i<=9; ++i) {
        coll.push_back(i);
    }

    PRINT_ELEMENTS(coll,"initialized:                ");

    // add value 10 to each element
    for_each (coll.begin(), coll.end(),    // range
              AddValue(10));               // operation

    PRINT_ELEMENTS(coll,"after adding 10:            ");

    // add value of first element to each element
    for_each (coll.begin(), coll.end(),    // range
              AddValue(*coll.begin()));    // operation

    PRINT_ELEMENTS(coll,"after adding first element: ");
}
-------------------------------------------------------------------------
operator()中的参数为container中的元素
�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q?BR>
另外的实例：(x��)
Function Objects as Sorting Criteria

Programmers often need a sorted collection of elements that have a special class (for example, a collection of persons). However, you either don't want to use or you can't use the usual operator < to sort the objects. Instead, you sort the objects according to a special sorting criterion based on some member function. In this regard, a function object can help. Consider the following example:
// fo/sortl.cpp #include #include #include #include using namespace std; class Person { public: string firstname() const; string lastname() const; ... }; /* class for function predicate * - operator() returns whether a person is less than another person */ class PersonSortCriterion { public: bool operator() (const Person& p1, const Person& p2) const { /* a person is less than another person * - if the last name is less * - if the last name is equal and the first name is less */ return p1.lastname() //declare set type with special sorting criterion typedef set PersonSet; //create such a collection PersonSet coll; ... //do something with the elements PersonSet::iterator pos; for (pos = coll.begin(); pos != coll.end();++pos) { ... } ... }

//fo/foreach3.cpp #include #include #include using namespace std; //function object to process the mean value class MeanValue { private: long num; //number of elements long sum; //sum of all element values public: //constructor MeanValue() : num(0), sum(0) { } //"function call" //-process one more element of the sequence void operator() (int elem) { num++; //increment count sum += elem; //add value } //return mean value double value() { return static_cast(sum) / static_cast(num); } }; int main() { vector coll; //insert elments from 1 to 8 for (int i=1; i<=8; ++i) { coll.push_back(i); } //process and print mean value MeanValue mv = for_each (coll.begin(), coll.end(), //range MeanValue()); //operation cout << "mean value: " << mv.value() << endl; }

inwind 2005-12-14 18:24 发表评论

inwind — Wed, 07 Dec 2005 02:50:00 GMT

   一、C 风格�Q�C-style�Q�强制�{型如下：(x��)

    (T) expression // cast expression to be of type T
    函数风格�Q�F(tu��n)unction-style�Q�强制�{型��用这��L(f��ng)��语法�Q?BR>    T(expression) // cast expression to be of type T
    �q�两�U��Ş式之间没有本质上的不同，它纯�_�就是一个把括号攑֜�哪的问题。我把这两种形式�U�Cؓ(f��)旧风��|��old-style�Q�的强制转型�?

   二�?C++的四�U�强制�{型�Ş式：(x��)

　　C++ 同时提供了四�U�新的强制�{型�Ş式（通常�U�Cؓ(f��)新风格的�?C++ 风格的强制�{型）�Q?
　　const_cast(expression)
　　dynamic_cast(expression)
　　reinterpret_cast(expression)
　　static_cast(expression)

　　每一�U�适用于特定的目的�Q?

　　dynamic_cast 主要用于执行“安全的向下转型�Q�safe downcasting�Q�”，也就是说�Q�要��定一个对象是否是一个��承体�p�M��的一个特定类型。它是唯一不能用旧风格语法执行的强制�{型，也是唯一可能有重大运行时代�h(hu��n)的强制�{型�?BR>
     static_cast 可以被用于强刉��型�{换（例如�Q�non-const 对象转型�?const 对象�Q�int 转型�?double�Q�等�{�）�Q�它�q�可以用于很多这��L(f��ng)��转换的反向�{换（例如�Q�void* 指针转型为有�c�d��指针�Q�基�c�L��针�{型�ؓ(f��)�z��c�L��针）�Q�但是它不能��一�?const 对象转型�?non-const 对象�Q�只�?const_cast 能做刎ͼ��Q�它最接近于C-style的�{换�?BR>
　　 const_cast 一般用于强制消除对象的帔R��性。它是唯一能做到这一点的 C++ 风格的强制�{型�?

　　 reinterpret_cast 是特意用于底层的强制转型�Q�导致实��C��赖（implementation-dependent�Q�（��是��_(d��)��不可�U�L��Q�的�l�果�Q�例如，��一个指针�{型�ؓ(f��)一个整数。这��L(f��ng)��强制转型在底层代码以外应该极为罕见�?BR>　　
　　旧风格的强制转型依然合法�Q�但是新的�Ş式更可取。首先，在代码中它们更容易识别（无论是�h�q�是�?grep �q�样的工具都是如此）�Q�这样就��化了在代码中��L��c�d��pȝ��被破坏的地方的过�E�。第二，更精��地指定每一个强制�{型的目的�Q��得编译器诊断使用错误成�ؓ(f��)可能。例如，如果你试图��用一�?const_cast 以外的新风格强制转型来消除常量性，你的代码��无法编译�?

==
== dynamic_cast .vs. static_cast
==

class B { ... };
class D : public B { ... };

void f(B* pb)
{
   D* pd1 = dynamic_cast(pb);
   D* pd2 = static_cast(pb);
}

If pb really points to an object of type D, then pd1 and pd2 will get the same value. They will also get the same value if pb == 0.

If pb points to an object of type B and not to the complete D class, then dynamic_cast will know enough to return zero. However, static_cast relies on the programmer’s assertion that pb points to an object of type D and simply returns a pointer to that supposed D object.

    即dynamic_cast可用于��承体�p�M��的向下�{型，卛_��基类指针转换为派生类指针�Q�比static_cast更严格更安全。dynamic_cast在执行效率上比static_cast要差一�?但static_cast在更宽上范围内可以完成映��?�q�种不加限制的映��伴随着不安全�?static_cast覆盖的变换类型除�c�d��ơ的静态导航以�?�q�包括无映射变换,�H�化变换(�q�种变换�?x��)导致对象切�?丢失信息),用VOID*的强制变�?隐式�c�d��变换�{?..

==
== static_cast .vs. reinterpret_cast
==

    reinterpret_cast是�ؓ(f��)了映��到一个完全不同类型的意�?�q�个关键词在我们需要把�c�d��映射回原有类型时用到�?我们映射到的�c�d��仅仅是�ؓ(f��)了故弄玄虚和其他目的,�q�是所有映��中最危险�?(�q�句话是C++�~�程思想中的原话)

    static_cast �?reinterpret_cast 操作�W�修改了操作数类�? 它们不是互逆的; static_cast 在编译时使用�c�d��信息执行转换, 在�{换执行必要的��?诸如指针��界计算, �c�d��?. 其操作数相对是安全的. 另一斚w��, reinterpret_cast 仅仅是重新解释了�l�出的对象的比特模型而没有进行二�q�制转换, 例子如下:

    int n=9; double d=static_cast < double > (n);

    上面的例子中, 我们��一个变量从 int 转换�?double. �q�些�c�d��的二�q�制表达式是不同�? 要将整数 9 转换�?双精度整�?9, static_cast 需要正��地为双�_�ֺ�整数 d 补��比特�? 其结果�ؓ(f��) 9.0. 而reinterpret_cast 的行为却不同:

    int n=9;
    double d=reinterpret_cast (n);

    �q�次, �l�果有所不同. 在进行计��以�? d 包含无用�? �q�是因�ؓ(f��) reinterpret_cast 仅仅是复�?n 的比特位�?d, 没有�q�行必要的分�?

inwind 2005-12-07 10:50 发表评论

欧美一级专区,国语自产精品视频在线看,亚洲欧洲日本一区二区三区

WordFeatureLib�~�程�W�记

数组和指针的比较

C/C+语言struct深层探烦 (转自CSDN)

vc6函数调用���析

函数对象

vc6函数调用��析