VC++的优化技术，从两个方面进行考虑，即代码速度和代码大小，这两个方面并非一定要放在一起考虑，视具体的情况而定。比如，某一个模块需要只有5KB的内存空间，我们程序只能在5KB的环境下运行，在这种情况下，最小代码是我们追求的目标。从编译器的角度讲如何对代码进行优化处理呢？

2、实现技巧

      根据所建立的目标不同，VC++预定义了一套自己的优化配置选项，例如当建立调试版本时，关闭所有的优化开关，保证可执行文件是源文件的直接翻译。对于发行版本，其默认优化是以最快速度为目的的。这是以增加代码量为代价的。这两种建立应用程序的方法能满足大多数应用程序的需求。但是，有时需要手工设置编译器优化选项。

      选择【Project】—>【Settings】菜单命令，弹出“Project Settings”对话框，

      其中图的“C/C++”标签页，包含了所有控制编译器优化一个工程文件的所有开关，如下图所示

      优化选项列表依赖于对“Category”下拉列表框的选择，其中3个包含了与编译器相关的所有开发组件，它们分别是General、Code Generation、Cunstomize，如图所示

      其中“General”包含的优化选项有Defaut、Disable、Maximize Speed、Minimize Size和Customize，在其中可以选择最快速度和最小代码。

      Link(连接)错误时常见的错误，其中又以Link2001最为常见，引起Link2001错误的原因是什么呢？

2、Link2001错误原因及实现技巧

    （1）由于编码错误导致的Link2001错误

      ①不相匹配的程序代码或模块定义（.DEF）文件导致Link2001。例如，如果在C++源文件内声明了一变量“var1”，视图却在另一个文件内以变量“var1”访问该变量。

      ②如果使用的内联函数是在.cpp文件内定义的，而不是在头文件内定义将导致Link2001错误

      ③调用函数如果所用的参数类型头函数与声明时的类型不符将会产生Link2001错误

      ④视图从基类的构造函数或析构函数中调用虚拟函数时将会导致Link2001错误

      ⑤要注意函数和变量的可公用性，只有全局变量、函数是可共用的。静态函数和静态变量具有相同的使用范围。当试图从文件外部调用任何没有在该文件内声明的静态变量时将导致编译错误或Link2001错误。 

    （2）由于编译和联机的设置而造成的Link2001错误

      ①如果编译时使用的是/NOD(/NODERAULTLIB)选项，程序所需要的运行库和MFC将由编译器写入目标文件模块，但除非在文件中明确包含这些库名，否则这些库不会被链接进工程文件。这种情况下使用/NOD将导致Link2001错误。

      ②如果没有为WinMainCRTStartup设定程序入口，在使用Unicode和MFC时将得到“unresolved external on WinMain@16“的Link2001错误信息。

      ③使用/MD选项编译时，既然所有的运行库都被保留在动态链接库之内，如果源文件中对“func”的引用，在目标文件里即对“__imp__func”的引用。如果试图使用静态库LIBC.lib或LIBCMT.lib进行链接，将在__imp__func上发生Link2001错误。如果不使用/MD选项编译，在使用MSVCxx.lib链接时也会发生Link2001错误。

      ④在使用/ML编译时，如用LIBCMT.lib链接会在_errno上发生Link2001错误。

      ⑤当编译调试版的应用程序时，如果采用发行版模态库进行链接也会产生Link2001错误；同样，使用调试版模态库链接发行版应用程序时也会产生相同的错误。

      ⑥不同版本的库和编译器的混合使用也能产生问题，因为新库的库里可能包含早先的版本没有的符号和说明。

      ⑦在不同的模块中使用内联和非内联的编译选项能够导致Link2001错误。如果创建C++库时打开了函数内联（/Ob2或/Ob2），但是在描述该函数的相应头文件却关闭了函数内联（没有inline关键字），将得到错误信息。为避免该问题的发生，应该在相应的头文件中用inline关键字标志位内联函数。

 
想要获得更多内容，可点击：《Visual C++代码参考与技巧大全》学习笔记——索引随笔

      ①覆盖：覆盖指的是派生类的虚拟函数覆盖了基类的同名且参数相同的函数。

      ②重载：必须在一个域中，函数名称相同但是函数参数不同，重载的作用就是同一个函数有不同的行为，因此不是在一个域中的函数是无法构成重载的，这是重载的重要特征。

      ③隐藏：是派生类的成员函数隐藏了基类函数的成员函数，在调用一个类的成员函数的时候，编译器会沿着类的继承链逐级向上查找函数的定义，如果找到了就停止查找，所以如果一个派生类和一个基类都有同一个同名（暂且不论参数释放相同）的函数，而编译器最终选择了在派生类中的函数，那么我们就说这个派生类的成员函数“隐藏”了基类的成员函数，也就是说它阻止了编译器继续向上查找函数的定义。

2、 成员函数被重载的特征

      ①相同的范围（在同一类中）

      ②函数名字相同

      ③参数不同

      ④virtual关键字可有可无

3、 覆盖的特征

      ①不同的范围（分别位于派生类与基类）

      ②函数名字相同

      ③参数相同

      ④基类函数必须有virtual关键字

4、 “隐藏”的规则

      如果派生类的函数与基类的函数同名，但是参数不同。此时，不论有无virtual关键字，基类的函数将被隐藏（注意别与重载混淆）。

      如果派生类的函数与基类的函数同名，并且参数也相同，但是基类函数没有virtual关键字。此时，基类的函数被隐藏（注意别于覆盖混淆）。

#include <iostream>
using namespace std;
class Base
{
public:
    virtual void f(float x){cout<<"Base::f(float) "<<X<<endl;}
    void g(float x){cout<<"Base::g(float) "<<x<<endl;}
    void h(float x){cout<<"Base::h(float) "<<endl;}
};
class Derived:public Base
{
public:
    //函数Derived::f(float)覆盖了Base::f(float)
    virtual void f(float x){cout<<"Derived::f(float) "<<x<<endl;}
    //函数Derived::g(int)隐藏了Base::g(float)，而不是重载
    void g(int x){cout<<"Derived::g(int) "<<x<<endl;}
    //函数Derived::h(float)隐藏了Base::h(float)，而不是覆盖
    void h(float x){cout<<"Derived::h(float) "<<x<<endl;}
};

      多态可以简单地概括为“一个接口，多种方法”，在程序运行的过程中才决定调用的函数。多态是面向对象编程领域的核心概念。

2、 多态的实现

      多态往往借助于虚函数实现，把基类和派生类中相同的函数同时定义为虚函数。在一个含有基类和派生类的程序中，往往各个类中相应的成员函数具有相同的函数名、返回类型和参数表，但函数体不同。在每个类中都有实现相应功能的成员函数。

      当一个派生类的对象的地址赋给一个基类的指针后，基类指针只能访问所属的成员函数，不能访问该派生类对象中与基类成员函数相同的成员函数。但在实际应用中，需要把一个基类或派生类的对象的地址赋给一个基类的指针后，基类指针能够访问基类或派生类中与基类成员函数相同的成员函数。虚函数的定义方法时在成员函数前加关键字virtual。

      当基类和派生类中相同的函数定义为一组虚函数后，通过基类指针可以调用任一类中的虚函数。

#include <iostream>
using namespace std;
class Base
{
//构造函数和析构函数
public:
    Base(){cout<<"Base构造函数"<<endl;}
    virtual ~Base(){cout<<"Base析构函数"<<endl;}
public:
    virtual void foo()
    {
        cout<<"Base"<<endl;
    }
};
/**//**//**//**//**//**//**//*********************************************************/
/**//**//**//**//**//**//**//*
/*********************************************************/
class A:public Base
{
public:
    A(){cout<<"A 构造函数"<<endl;}
    virtual ~A(){cout<<"A 析构函数"<<endl;}
public:
    virtual void foo()
    {
        cout<<"A"<<endl;
    }
};
/**//**//**//**//**//**//**//*********************************************************/
/**//**//**//**//**//**//**//*
/*********************************************************/
class B:public Base
{
public:
    B(){cout<<"B 构造函数"<<endl;}
    ~B(){cout<<"B 析构函数"<<endl;}
public:
    virtual void foo()
    {
        cout<<"B"<<endl;
    }
};
/**//**//**//**//**//**//**//*********************************************************/
/**//**//**//**//**//**//**//*
/*********************************************************/
int main()
{
    Base* pBase=NULL;
    pBase=new A;
    pBase->foo();
    if(pBase!=NULL)
    {
        delete pBase;
        pBase=NULL;
    }

    pBase =new B;
    pBase->foo();
    if(pBase!=NULL)
    {
        delete pBase;
        pBase=NULL;
    }
    return 0;
}

代码的输出结果如下：


想要获得更多内容，可点击：《Visual C++代码参考与技巧大全》学习笔记——索引随笔

      每个类必须有默认的构造函数，没有构造函数就不能创建对象。若没有提供任何函数，那么C++自动提供一个默认的构造函数，该默认构造函数是一个没有参数的构造函数，它仅仅复制创建对象而不做任何赋值操作。只要类中提供了任意一个构造函数，那么C++就不再自动提供默认构造函数。析构函数也是特殊的类成员函数，它没有返回类型，没有参数，不能随便调用，也没有重载，只有在类对象的生命周期结束的时候，由系统自动调用。二者的最大不同在于调用期不同，构造函数可以有参数，可以重载。

2、 构造函数和析构函数的应用注意事项

      ①如果构造函数没有参数，声明对象时不要带有括号。

      ②构造函数没有返回值，所以不能把它声明为void函数，尽管它实际上默认为void类型，也不能声明为void类型。

      ③对一个类而言，可以定义多个重载的构造函数，但是它们必须有完全不同的参数表。

      ④析构函数可以为virtual类型，而构造函数不能为virtual类型，是因为虚函数采用一种虚调用的办法，虚调用是一种在只有部分信息的情况下的工作机制，特别允许一个只知道接口而不知其准确对象类型的函数访问，但是要创建一个对象，就要知道其准确的类型，因此构造函数不可为虚。

      ⑤析构函数可以使内联函数

3、 实例代码

      但是在C++中struct和class意义一样，唯一不同就是struct里面默认的访问控制是public，class中默认的访问控制是private。在C++中struct中也可以构造函数、析构函数、它们之间也可以继承

      下面的代码演示了struct继承的例子：

#include<iostream.h>
/**//*******************************************************/
/**//* 动物基类
/*******************************************************/
enum BREED{GOLDEN,CAING,DANDIE,SHETLAND,DOBERMAN,LAB};
struct Animal
{
public:
    Animal():m_nAge(2),m_nWeight(20){}
    ~Animal(){}
//操作
public:
    int GetAge() const{return m_nAge;}//get the age of the animal
    void SetAge(int nAge){m_nAge=nAge;}//set the age of the animal
    int GetWeight()const{return m_nWeight;}//get the wight of the animal
    void SetWeight(int nWeight){m_nWeight=nWeight;}//set the weight of the animal
//属性
protected:
    int m_nAge;
    int m_nWeight;
};
/**//*******************************************************/
/**//*
/*******************************************************/
struct Cat:public Animal
{
public:
    Cat():m_Breed(GOLDEN){}
    ~Cat(){}
public:
    BREED GetBreed()
    {
        return m_Breed;
    }
    void SetBreed(BREED breed)
    {
        m_Breed=breed;
    }
private:
    BREED m_Breed;
};
/**//*******************************************************/
/**//* 主函数
/*******************************************************/
int main()
{
    Cat cat;
    int nAge;
    int nWeight;
    BREED breed;
    cat.SetAge(10);
    cat.SetWeight(100);
    cat.SetBreed(GOLDEN);

    nAge=cat.GetAge();
    nWeight=cat.GetWeight();
    breed=cat.GetBreed();

    cout<<"Age = "<<nAge<<endl;
    cout<<"Weight = "<<nWeight<<endl;
    cout<<"BREED = "<<breed<<endl;
    return 0;
}

      程序在内存中有4个区域，即代码区、全局数据区、栈区和堆区。全局数据区、栈区都是静态分配区域；堆是程序运行时动态使用的一个内存空间，如果要在堆中分配内存空间，必须使用特定的函数和操作符。另外，若不再需要分配的空间则必须释放。

2、 堆内存的申请和释放

      malloc与free和new/delete是C++的运算符，它们都可用于申请动态内存和释放内存，但是malloc/free无法满足动态对象的要求。对象在创建的同时要自动执行构造函数，对象在消亡之前要自动执行析构函数。由于malloc/free是库函数而不是运算符，不在编译器控制权限之内，不能够把执行构造函数和析构函数的任务强加于malloc/free。因此C++语言需要一个能完成动态内存分配和初始化工作的运算符new，以及一个能够完成清理和释放内存工作的运算符delete。

      malloc函数的原型为：

void * malloc(unsigned long);

      参数unsigned long类型的表达式，用来表示需分配的内存单元（单位是字节）数量。函数返回void *型的指针，指向分配内存块的首地址。由于malloc函数返回的地址是void*类型，因此不能直接被使用，所以引用该函数时都必须进行类型转换。

      free的函数原型为：

void free(void *);

      用malloc函数在堆内分配的空间系统不会自动释放，必须由程序设计者在程序中用free函数来释放。

      C++所独有的开辟和释放对内存空间的方法——new修饰符和delete修饰符，new和delete修饰符的操作并不需要头文件的支持，这是C++所独有的new操作要比malloc更为简单，直接说明开辟的类型的数目就可以了，delete使用的时候如果是数组那么必须使用delete[]。

3、 实例代码
（未完待续）

想要获得更多内容，可点击：《Visuanl C++代码参考与技巧大全》学习笔记——索引随笔

1、 野指针的概念

      “野指针”不是NULL指针，是指向“垃圾”内存的指针。在一般情况下不会错用NULL指针，因为用if语句很容易判断。但是“野指针”是很危险的，if语句对它不起作用。

2、 杜绝野指针的方法

      杜绝“野指针”有3种主要方法：

      ①指针变量没有被初始化。任何指针变量刚被创建时不会自动成为NULL指针，它的默认值是随机的，它会乱指一气。所以指针被定义后，一定要初始化。

      ②指针p被释放或删除之后，没有置为NULL，让人误以为p是个合法的指针。相反指针被释放后要设为NULL，以免出错。

      ③指针操作超越了变量的作用范围。对指针的操作范围要进行检查，确保越限错误发生率最低。

#include <iostream>
using namespace std;
void GetMemory(char *p,int num)
{
    p=(char *)malloc(sizeof(char) * num);
}
void Test(void)
{
    char *str=NULL;
    GetMemory(str,100);    //str仍然为NULL
    strcpy(str,"hello");//运行错误
}
int main()
{
    Test();
    return 0;
}

      上面的代码在编译无错误的，可是在执行时，出现了错误。调试发现，str仍然为NULL。str并没有指向GetMemory()所申请的内存，在函数被调用时，编译器会被调用函数的参数产生一个副本_p，使_p=p，如果函数体内修改_p的内容，那么导致参数p的内容作相应的修改，这就是指针可以作为输出参数的原因。在本例中，_p重新申请了一块内存，只是把_p所指的内存地址改变了，但是p丝毫未变。所以GetMemory并不能返回任何东西。所以str仍然为NULL，导致程序运行错误。事实上，每执行一次GetMemory()，就会造成内存的泄露，因为申请的内存并没有被释放。
       如果要用指针参数申请内存，使用指向指针的指针可以完成此功能：

#include <iostream>
using namespace std;
void GetMemory(char **p,int num)
{
    *p=(char *)malloc(sizeof(char) * num);
}
void Test(void)
{
    char *str=NULL;
    GetMemory(&str,100);    //注意参数是&str，而不是str
    strcpy(str,"hello");
    cout<<str<<endl;
    free(str);
}
int main()
{
    Test();
    return 0;
}

2、函数返回值传递动态内存

#include <iostream>
using namespace std;
char *GetMemory(int num)
{
    char *p=(char *)malloc(sizeof(char) * num);
    return p;
}
void Test(void)
{
    char *str=NULL;
    str=GetMemory(100);
    strcpy(str,"hello");
    cout<<str<<endl;
    free(str);
}
int main()
{
    Test();
    return 0;
}

#include <iostream>
using namespace std;
char *GetMemory(void)
{
    char *p="hello world";
    //书上说，这句话编译器应该提出警告，但是vc6没有
    return p;    
}
void Test(void)
{
    char *str=NULL;
    str=GetMemory();    //书上说str的内容是垃圾
    cout<<str<<endl;
}
int main()
{
    Test();
    return 0;
}

      this指针是一个隐含的指针，它是指向对象本身的，代表了对象的地址。一个类所有的对象调用的成员函数都是同一代码段，那么成员函数又是怎么识别属于不同对象的数据成员呢？

2、 this指针的应用

      在对象调用成员函数时，成员函数除了实参外，还接受对象的地址，这个地址被一个隐含的形参this指针所获取，它等同于执行this=&对象名。所有对数据成员的访问都隐含地被加上前缀this->。例如，x=0; 等价于this->x=0。

3、 实例代码

#include <iostream>
using namespace std;
class point
{
public:
    int x;
    int y;
    point()
    {
        x=0;
        y=0;
    }
    point(int a,int b)
    {
        x=a;
        y=b;
    }
    void output()
    {
        cout<<"x = "<<x<<endl<<"y = "<<y<<endl;
    }
    void input(int x,int y)
    {
        x=x;
        y=y;
    }
};
void main()
{
    point pt(5,5);
    pt.input(10,10);
    pt.output();
}

    void input(int x,int y)
    {
        (*this).x=x;
        (*this).y=y;
    }

    void input(int x,int y)
    {
        this.x=x;
        this.y=y;
    }

      ①非空区别

      在任何情况下都不能使用指向空值的引用。一个引用必须总是指向某些对象，因此如果使用一个变量并让它指向一个对象，但是该变量在某些时候也可能不指向任何对象，这时应把变量声明为指针，因为这样可以赋空值给该变量。相反，如果变量肯定指向一个对象，这时可以把变量声明为引用。引用的代码效率比使用指针要高（为什么，可以看汇编）。

      ②合法性区别

      在使用引用之前不需要测试它的合法性，相反，指针应该总是被测试的，防止其为空。

      ③可修改区别

      指针可以被重新赋值以指向新的对象，但是引用则总是指向初始化时被指向的对象，以后不能够改变，但是指向的内容可以改变。

2、 实例代码

#include <iostream>
using namespace std;
int main()
{
    char* p;
    int i=2;
    int & n=i;

    //声明两个字符串数组
    char ch1[20]="abce";
    char ch2[20]="1234";

    
    p=ch1;    //p指向ch1
    cout<<p<<endl;
    p=ch2;    //p指向ch2
    cout<<p<<endl;

    cout<<"i = "<<i<<endl;
    cout<<"n = "<<n<<endl;

    n=5;    //对n重新赋值
    cout<<"i = "<<i<<endl;
    cout<<"n = "<<n<<endl;
    return 0;
}

      指针和数组存在特殊的关系，很容易混淆。获取数组第一个元素的地址，可以采用两种方法，第一种采用地址运算符&来实现，第二种方法直接使用数组的名字。代码如下：

float dues[] ={11.00,58.00,45.00};
float dp1 =&dues[0]
//或者
float dp2=dues;

      进一步讨论如何获取数组中的任何一个值的地址，一个数组地址后面跟上加号和一个整型表达式，就相当于以该整型表达式作为下标的数组元素的地址。例如：

float dues[] ={11.00,58.00,45.00}
float dp1 =&dues[2]
//或者
float dp2=dues+2;

2、 数组和指针的关系

      数组的标识符不像一般变量的标识符，数组标识符不是左值，不能给它赋值，它只是一个进入方括号语法的手段，也是数组存储数据的起始地址。所以数组的标识符可以看做是只读的指针，而指针的内容是可以改变的。代码参考如下：

int a[10];
int *p = a;
for(int i=0;i<10;i++)
{
    a[i]=i*10;
}

      上面的操作是给数据a赋初始值。

      下面的操作时给数据a赋值，并把原来的数值覆盖掉。

for(int i=0;i<10;i++)
{
    p[i]=i*15;
}

      一个大型的C++程序中最容易出现，也是最头疼的一个问题就是内存泄露，即忘记释放已经申请的内存，造成程序占用的内存不断上升，系统性能不断下降，甚至造成内存耗尽而导致程序崩溃。在Java中提供自动垃圾回收机制，程序在何时的时机将回收内存，C++语言一直没有将这种机制作为语言的内部机制，但是它也提供了足够的灵活机制，使开发人员有效地避免内存泄露。

2、 内部封装

      可以将分配和释放的过程封装到一个类中，即在构造的时候申请内存，析构的时候释放内存，从而保证没有内存泄露。下面是一个简单的封装类。

#include <iostream>
#include <cstring>
using namespace std;
class AutoNewDel
{
private:
    char* m_szBuf;
    unsigned int m_nSize;
public:
    AutoNewDel(unsigned int n=1)
    {
        m_szBuf=new char[n];
        m_nSize=n;
    };
    ~AutoNewDel()
    {
        if(m_szBuf!=NULL)    //提供安全机制
        {
            delete[] m_szBuf;    //删除字符数组
            m_szBuf=NULL;    //防止出现野指针
        }
    };
    char* GetBuf()
    {
        return m_szBuf;
    };
};
void fun()
{
    AutoNewDel tmpObj(100);
    char* p= tmpObj.GetBuf();
    strcpy(p,"one world, one dream");
    cout<<p<<endl;
}
int main()
{
    fun();
    cout<<"exit main"<<endl;
    return 0;
}

void fun()
{
    AutoNewDel tmpObj(100);
    AutoNewDel tmpObj2=tmpObj;//这里是增加的语句
    char* p= tmpObj.GetBuf();
    strcpy(p,"one world, one dream");
    cout<<p<<endl;
}

#include <iostream>
#include <cstring>
using namespace std;
class AutoNewDel
{
// Attribute
private:
    char* m_szBuf;
    unsigned int m_nSize;
    int * m_count;    //新增加的语句
public:
    AutoNewDel(unsigned int n=1)//在构造函数中申请内存
    {
        m_szBuf=new char[n];
        m_nSize=n;
        //新增加的语句
        m_count=new int;
        *m_count=1;
        cout<<"count is : "<<*m_count<<endl;
    };
    //新增加的复制构造函数
    AutoNewDel(const AutoNewDel & s)
    {
        m_nSize=s.m_nSize;
        m_szBuf=s.m_szBuf;
        m_count=s.m_count;
        (*m_count)++;
        cout<<"count is : "<<*m_count<<endl;
    }
    ~AutoNewDel()
    {
        (*m_count)--;
        cout<<"count is : "<<*m_count<<endl;//新增加的两条语句
        
        if(*m_count==0)
        {
            cout<<"buf is deleted"<<endl;
            if(m_szBuf!=NULL)    //提供安全机制
            {
                delete[] m_szBuf;    //删除字符数组
                m_szBuf=NULL;    //防止出现野指针
                if(m_count!=NULL)
                {
                    delete m_count;
                    m_count=NULL;
                }
            }
        }
    };
    char* GetBuf()
    {
        return m_szBuf;
    };
};
void fun()
{
    AutoNewDel tmpObj(100);
    char* p= tmpObj.GetBuf();
    strcpy(p,"one world, one dream");
    cout<<p<<endl;

    AutoNewDel tmpObj2=tmpObj;
    cout<<"tmpObj2.m_szBuf = "<<tmpObj2.GetBuf()<<endl;
}
int main()
{
    fun();
    cout<<"exit main"<<endl;
    return 0;
}

      内存管理是C++最重要的一部分，也是C++最有争议的问题。用户可以从内存管理获得更大的自由度及更好的性能优化，但同时也带来极大的隐患，如果用不好很容易造成内存的泄露，因此，如意要真正掌握C++的核心，必须要精通C++的内存管理机制。目前的Java和.NET都提供了内存管理的自动机制，但是是以牺牲对使用内存的支配权为代价的，放弃了C++的绝对优越性。

1、 程序的内存区

      一般而言，计算机的内存区域由代码和数据组成，这两个部分也是影响一个程序所需内存的重要因素。代码是允许的指令，例如数学运算、比较、跳转即函数调用等，其大小通常是由程序的功能及复杂程度决定的。当然，正确地使用程序的编写技巧及编程语言的语法特性会优化产生代码的大小，数据是代码要处理的对象。一个程序占用的内存区域一般分为5种，它们是：全局/静态数据区、常用数据区、代码区、栈、堆等。程序的代码存储在代码区中，而程序的数据则要根据数据种类的不同，存储在不同的内存区。

2、 内存的分配方式

      ① 从静态存储区域分配。内存在程序编译的时候就已经分配好，这块内存在程序的整个运行期间都存在。例如，全局变量、static变量及字符串常量。这部分存储区是在程序编译阶段已分配好，在整个程序运行过程中始终存在，用于存储全局变量、静态变量及字符串常量等。其中，字符串常量的存储区域是不可修改的内存区域，如下面的这段代码会导致程序运行中断：

#include <iostream>
using namespace std;
int main()
{
    //指向一个字符串常量
    char* pLocalString = "this is a test";
    /**//* 下面这句提示错误：error C2440: '=' : 
     * cannot convert from 'const char' to 'char *'
     * 试图修改不可修改的内存区
     */
    pLocalString='#';
    //cout<<pLocalString<<endl;
    return 0;
}

      ②从栈上创建。在执行函数时，函数局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。      

      ③在栈上分配，亦称动态内存分配。程序在运行的时候用malloc或new申请任意多的内存，程序员自己负责在何时用free或delete释放内存。动态内存生存期由程序员决定，使用非常灵活，但问题也最多，很容易造成内存泄露。

3、 代码参考

      通过下面的程序，来说明各种类型的数据在内存中的位置。 

#include <stdio.h>
#include <stdlib.h>
int nGlobal=100;
int main()
{
    char* szLocalString1="LocalString1";
    const char* szLocalString2="LocalString2";
    static int nStatic =100;
    int nLocal=1;
    const int nLocalConst=200;
    int* pNew=new int[5];
    char* szMalloc=(char*)malloc(1);

    printf("global variable:0x%x\n",&nGlobal);
    printf("static variable:0x%x\n",&nStatic);
    printf("\n");
    printf("local expression 1:0x%x\n",szLocalString1);
    printf("local expression 2:0x%x\n",szLocalString2);
    printf("\n");
    printf("new 0x%x\n",&pNew);
    printf("local pointer(szLocalString1):0x%x\n",&szLocalString1);
    printf("local pointer(szLocalString2):0x%x\n",&szLocalString2);
    printf("\n");
    printf("local variable:0x%x\n",&nLocal);
    printf("local pointer(szMalloc):0x%x\n",&szMalloc);
    printf("local const variable:0x%x\n",&nLocalConst);

    return 0;
}

      由于dll本身是不可执行的，所以给开发和调试工作带来了一定得难度，在VC++中如何调试dll程序呢？提供了两种解决办法

2、调试dll的技巧

      打开应用程序的工程，选择【Project】—>【Settings】菜单命令，在弹出对话框的“Debug”标签下，“Category”选择“General”，在“Program Arguments”中指定应用程序命令行参数。“Category”选择“Additional dlls”，输入调试的dll文件，如果使用远程调试，要给出完整的网络路径。这个dll必须编译成Debug版本的程序，包含有调试信息。这样尽管dll源不是这个工程的组成部分，也可以在应用程序和dll的源程序中设置断点。同时使用应用程序的工程来调用dll

      在同一个工程区内打开dll和应用程序，这样就要求把dll程序的工程添加到应用程序的工作区中。为了能够调试dll程序，两个工程都是用相同版本的Debug。在【Project】—>【Settings】对话框的“Link”标签下选中“Generate debug info”。在【Project】—>【Settings】对话框的“Debug”标签下，“Category”选择“Additional DLLs”，将要调试的dll文件加入其中。同时，在【Project】—>【Settings】对话框中选择应用程序的工程依赖于dll的工程，在dll程序调用时，编译用户应用程序，可以根据文件新旧比较把dll的工程也编译连接。dll工程调用后，编译连接生成新版本调试信息，为了操作方便可以在dll工程的“Project Settings”对话框中的“Post-Build Step”标签下加上将编译好的dll复制到应用程序访问到的目录的一个命令。每编译一次，就要执行一次这个命令，将最新生成的dll文件提交给应用程序是用。

      通过上面的设置就可以通过应用程序来对dll程序进行调试了，在调试过程中，可以从应用程序单步跟踪到dll工程中，在dll中设置断点，在应用程序中调用dll，执行到此时，也会中断，从而达到了调试的目的。

      这个函数可以获得一个系统的错误代码，通过错误代码得到程序的问题所在，错误代码可以在MSDN上查到：System Errors - Numerical Order

2、代码参考

#include"stdafx.h"
#include<windows.h>
#include<stdio.h>
#include<iostream>
using namespace std;
int main(int argc, char* argv[])
{
    unsigned short us=(unsigned short)6553658;
    int errorcode=GetLastError();
    char sz[100];
    sprintf(sz,"error %d",errorcode);
    MessageBox(NULL,sz,"Tip",MB_OK);
    return 0;
}

       在函数调用、内存申请、数值计算时，在出错的地方尽量多调用GetLastError()。

      提倡在程序当中多使用Try-Catch，用此结构来捕获代码运行当中产生的突发错误。比如说，对于用ADO操作的数据库，那么打开的过程就写在try语句里。对于数据流的写入存储操作，也要用其来捕获错误。

      try-catch语句由一个try块和其后所跟的一个或多个catch子句构成，每个子句为不同的异常指定处理程序。try关键词后跟可能出错的语句，catch子句后跟相应错误的处理语句。

2、代码参考

      因原来做Java或C#项目的时候经常用到try-catch，这里就不尝试了。只附上书上说的一些不错的话。抱歉了。

      在进行内存申请、函数调用、数据库操作时，多用此语句，以便处理错误信息。

      我网上搜索了一下，有的是这么说的：

      “TRACE宏对于VC下程序调试来说是很有用的东西，有着类似printf的功能；该宏仅仅在程序的DEBUG版本中出现，当RELEASE的时候该宏就完全消失了，从而帮助你调式也在RELEASE的时候减少代码量。

　　使用非常简单，格式如下：

　　TRACE("DDDDDDDDDDD");

　　TRACE("wewe%d",333);

　　同样还存在TRACE0，TRACE1，TRACE2。。。分别对应0，1，2。。个参数

      TRACE信息输出到VC IDE环境的输出窗口（该窗口是你编译项目出错提示的哪个窗口），但仅限于你在VC中运行你的DEBUG版本的程序。”

      觉得这个解释是比较不错，容易看懂的。

      同时，搜到一个东西，也没看懂，但觉得挺好的，说不定以后会用到，就贴这了。

      最近在做一个小工程，由于中间的算法比较繁琐，也非常杂乱，哪一个环节出了差错，全盘皆乱，特别希望在需要的地方输出一个监视值，以监视中间的算法执行情况，首先想到了设断点调试，但是每次都是在不断中断程序的情况下，非常不方便，试了一下TRACE，但是也必须在DEBUG调试模式下进行，感觉非常痛苦。偶一日，翻看候sir的深入浅出MFC，在附录里提供了一个以MFC重建DBWIN的详细解说，顿时欣喜若狂，仔细研读，里面提供了很多方法，但是我还是喜欢DBWIN这个工具，God，真是救我于水火阿，DBWIN这个程序已经给我们提供了，就在MSDN中，可以轻松获得，呵呵，这个可是鼎鼎大名的Paul DiLascia做出来的，不用怀疑它的功能，但是每次要使用这个工具的时候都必须修改源代码，确实比较麻烦，而且，还要注意调用初始化程序的位置，觉得有点不爽，稍微看了一下要求包含的一个头文件，和所要调用的初始化程序，心里盘算着能不能在生成DEBUG程序的情况下自己添加呢，初始化必须最先调用，对，构造一个全局对象，于是自己写了一个类，把初始化程序放在全局对象的构造函数中，源程序如下：

//MyTrace.h
#ifndef __MYTRACE_H__
#define __MYTRACE_H__
#ifdef _DEBUG
#include<tracewin.h>
class MyTrace
{
       public:
       MyTrace()
       {
              ::MfxTraceInit();
       }
       ~MyTrace(){}
};
MyTrace _mytrace;
#endif //_DEBUG
#endif //__MYRTACE_H__

      把这个文件和<tracewin.h>这两个文件放在了默认包含目录下，如果要使用DBWIN的时候只要把mytrace.h这个文件包含在你的程序里面就行了，最好是包含在构建theApp的那个文件中，这样可以监视你程序中想要监视的所有过程，哇，确实方便了许多。打开DBWIN窗口，你所加入的TRACE字符串清清楚楚的出现在监视窗口，你甚至不用开VC环境，自己运行你所生成的DEBUG程序，这样如果你要同时调试几个程序，如关系到程序间的通讯的，非常方便，看得也非常痛快。

      但是每次还要包含一个头文件，还是有点麻烦，可否把这个文件内嵌到AfxWin的头文件中呢，因为要编写MFC程序，这个头文件是必须包含的，赶紧try一下，不对，出现错误了，好像是出现重复定义，但是这个头文件已经使用预编译指令保证了不出现重复定义了阿，查看有关资料关于这个连接错误，哦，好像是由于VC的一些关系引起的，但是努力了好长时间还是没法解决，贴出这篇文章想请教各位大虾，也许你们对于TRACE有更好的方法，望赐教，对于我所出现的错误你们有更好的解决方法，也望告知，感激不尽。这里留下我的Mail，dyroro@163.com

      ASSERT()是调试程序时经常使用的宏，在程序运行时它计算括号内的表达式，如果表达式为FALSE(0)，程序将报告错误，并终止执行。如果表达式不为0，则继续执行后面的语句。这个宏通常判断原来程序中是否出现了明显非法的数据，如果出现了终止程序以免导致严重后果，同时也便于查找错误。不过ASSERT()只在Debug版本中有效。

2、代码参考
      
      唉，由于是初学者，对C++还未学透，我想不到办法测试，ASSERT()，当括号里面的表达式错误的时候所发生的情况。如有知晓者，望评论，指点一二，thanks了~！
      下面是我的代码，建立的依然是Win32 Console Application工程，选择第三个。

#include"stdafx.h"
#include<assert.h>
#include<string.h>
#include<iostream>
using namespace std;
//这个字符串赋值函数是Linus Torvalds写
char* cpy(char* dest,const char* source)
{
    //使用ASSERT宏断言dest和source非空，可以输出调试信息，在release版本里自动失效，比调试时无故死掉强
    //source和dest与NULL显式比较，强调他们是指针变量
    assert((NULL!=source)&&(NULL!=dest));
    char* returnstring=dest;
    //*dest++=*source++，是字符串赋值语句，
    //&：取地址运算符；*：指针运算符（或称“间接访问”运算符），取其指向的内容。
    //dest和source都是地址，++，就是下一个地址了，然后用*，取出这个地址的内容
    while((*dest++=*source++)!='\0')
    {
        ;
    }
    return returnstring;
}
int main(int argc, char* argv[])
{
    char src[]={'1','2','3','4'};
    char last[]={'4','3','2','1'};
    int i;
    cout<<"before using function:"<<endl;
    for(i=0;i<4;i++)
    {
        cout<<"last["<<i<<"]="<<last[i]<<endl;
    }
    cpy(last,src);
    cout<<"after using function:"<<endl;
    for(i=0;i<4;i++)
    {
        cout<<"last["<<i<<"]="<<last[i]<<endl;
    }
    return 0;
}

      调用堆栈反映了当前断点处函数是被哪些函数按照什么顺序调用的？

2、堆栈调试的技巧

      单击“Debug”工具条上的【Call Stack】就显示“Call Stack”对话框。在“Call Stack”对话框中显示了一个调用系列，最上面的是当前函数，往下依次是调用函数的上级函数，单击这些函数名可以跳到对应的函数中。

      观察变量的值，可以在断点状态下将鼠标放在该变量的上面，等一下就会显出变量的值。其实，VC还提供被称为Watch或Memory的机制来观看变量和表达式的值。下面对这两种调试方法逐一介绍。

2、调试技巧

      ①Watch机制

      VC提供一种被称为Watch的机制来观看变量和表达式的值。在断点状态下，在变量上单击鼠标右键，在弹出的快捷菜单中选择【Quick Watch】命令，就弹出一个对话框，显示这个变量的值。单击“Debug”工具条上的【Watch】按钮，就出现一个Watch视图（Watch1，Watch2），在该视图中输入变量或者表达式，就可以观察变量或者表达式的值。注意：这个表达式不能有副作用，例如++运算符绝对禁止用于这个表达式中，因为这个运算符将修改变量的值，导致软件的逻辑被破坏

      ②Memory机制

      由于指针指向的数组，Watch只能显示第一个元素的值。为了显示数组的后续内容，或者要显示一片内存的内容，可以使用Memory功能。在Debug工具条上单击【Memory】按钮，弹出一个对话框，在其中输入地址，就可以显示该地址指向的内存的内容。

      断点是一个信号，它通知调试器，在某个特定点上暂时将程序执行挂起。当在某个断点处挂起时，我们称程序处于中断模式，进入中断模式并不会终止或结束程序的执行，执行可以在任何时候继续。

      断点模式可以看做一种超时。所有元素（例如，函数、变量和对象）都保留在内存中，但他们的移动和活动被挂起了。在中断模式下，可以检查它们的位置和状态，以查看是否存在冲突或bug。你可以在中断模式下对程序进行调整。例如，可以更改变量的值。可以移动执行点，这会改变执行回复后将要执行的下一条语句。

2、断点调试

      断点是调试器设置的一个代码位置。当程序运行到断点时，程序中断执行，回到调试器。断点是最常用的技巧，调试时，只有设置了断点并使程序回到调试器，才能对程序进行在线调试。设置断点：【F9】，再按【F9】，去掉断点

      在编译程序时，Debug版本是可以调试的，程序员能够获得程序的运行状态。Release版本可以进行调试吗？

2、实现技巧

      在“Release”版的“Project Settings”里，把C/C++设置的“Debug info”设为“Program Database”，如图所示

      在“Link”选项卡中选择“Generate debug info”，这样就可以看着源码来调试Release版，而不用看着反汇编代码来调试那么辛苦了。由于Release版本一般是优化过的，所以有时你检查变量数值时所显示的数值不一定就是该变量当前的数值，但是程序执行顺序是不变的，如果真的要看其准确的数值的话，用反汇编来看，也许是在某个register里。调试完毕之后，把“Link”设置的“Generate browse info”去掉，重新连接一下就行。

      在VC工程比较大时，开发的软件通常会出现在Debug状态下能够正常运行，而在Release状态下无法正常运行的情况。这种错误的检查的前提是要弄清二者之间本质的区别。

2、Debug和Release的区别

      ①Debug版本包含了大量的调试信息，所以形成的可执行文件要比Release版本大。

      ②二者根据选择的编译选项不同，需要的支持库也不同，如果是MFC的工程，则需要MFC42D.dll等库支持，而Release版本则需要MFC42.dll的支持。

      ③Release Build不对源代码进行调试，不考虑MFC的诊断宏，使用的是MFC Release库，编译是对应用程序的速度进行优化，而Debug Build则正好相反，它允许对源代码进行调试，可以定义和使用MFC的诊断宏，采用MFC Debug库，对速度没有优化。

      以上从现象上介绍了Debug版本和Release版本之间的区别，它们的本质区别在于一组编译的开关量的设置，编译时开关量如表2-2和表2-3所示

表2-2 Debug版本编译选项表

表2-3 Release版本的编译选项表

1、 问题阐述

      项目工程已经建立，如果想改变当初为项目工程创建的项目名称，可以利用custom向导，重新建立一个除项目名称外与现有项目完全相同的新项目

2、 技巧阐述

(1)利用【File】菜单下生成新项目中的“Custom Appwizard”，输入想要创建的想到的名称“Ctrl”，如下图所示

(2)单击【OK】按钮，进入下一步设置，选择“An existing project”，如下图所示

(3)单击【Next】按钮，然后选择现有项目的项目文件名，如下图所示

(4)单击【Finish】按钮，生成向导，显示生成向导的信息，如下图所示

(5)编译向导，就生成了一个与现有项目相同但可以重新取名的项目的Appwizard，如下图所示

      可以同使用mfc appwizard一样用它。可以在vc安装目录的common\msdev98\template目录中删除该wizard中的.awx和.pdb文件，并删除该向导。

如果还想获得更多关于《Visual C++代码参考与技巧大全》的内容，可点击下面网址，http://www.cppblog.com/kangnixi/archive/2010/01/13/105591.html

该技巧未进行试验，所暂无图

1、 问题阐述

      产品在发布之前要进行发布设置，确定产品的版权、语言、版本及产品描述等。如何对版本进行修改呢？

2、 实现技巧

        进入资源视图，双击“VS_VERSION_INFO”展开此资源，再在右边的正文窗口中双击修改版本号，选择菜单【Bulid】—>【Rebuild All】命令，exe就变成了新版本号了。


如果还想获得更多关于《Visual C++代码参考与技巧大全》的内容，可点击下面网址，http://www.cppblog.com/kangnixi/archive/2010/01/13/105591.html