void   dialog5::OnRclickList1(NMHDR*   pNMHDR,   LRESULT*   pResult)    
  {  
  //   TODO:   Add   your   control   notification   handler   code   here  
  CMenu   menu1,*menu2;  
  CPoint   point1;  
  menu1.LoadMenu(IDR_MENU1);  
  menu2=menu1.GetSubMenu(0);  
  ::GetCursorPos(&point1);  
  menu2->TrackPopupMenu(TPM_LEFTALIGN|TPM_LEFTBUTTON|TPM_RIGHTBUTTON,  
  point1.x,point1.y,this);  
   
  *pResult   =   0;  
  }  

偶然发现的一个有用的windows api SetROP2(int nDrawMode)，现在将我对该api的使用的心得归纳如下： 该函数的主要的作用是根据nDrawMode设置的方式重新设定绘图的方式，下面就不同的nDrawMode值具体解释绘图模式是如何改变的。 首先就nDrawMode的取值有以下的情况： R2_BLACK   Pixel is always black.   //所有绘制出来的像素为黑色 R2_WHITE   Pixel is always white.    //所有绘制出来的像素为白色 R2_NOP   Pixel remains unchanged.   //任何绘制将不改变当前的状态 R2_NOT   Pixel is the inverse of the screen color. //当前绘制的像素值设为屏幕像素值的反，这样可以覆盖掉上次的绘图，（自动擦除上次绘制的图形） R2_COPYPEN   Pixel is the pen color.    //使用当前的画笔的颜色 R2_NOTCOPYPEN   Pixel is the inverse of the pen color.  //当前画笔的反色 /////////////////////////////////////////////////////////////////////////////////example/////////////////////////////////////////////////////////////////////////   ClientDC.SetROP2(R2_NOT);   ClientDC.MoveTo(m_PointOrigin);   ClientDC.LineTo(m_PointOld);   ClientDC.MoveTo(m_PointOrigin);   ClientDC.LineTo(point);   m_PointOld = point;   CView::OnMouseMove(nFlags, point); ///////////////////////////////////////////////////////////////////////////////////////end///////////////////////////////////////////////////////////////////////// 总之，上述api的一个作用是在需要改变绘图的模式时，不需要重新设置画笔，只需要设置不同的绘图的模式即可达到相应的目的。

#include<stdio.h>

struct a
{
 int b;
};
struct b
{
    int a;
};
void main()
{
 a A;
 A.b = NULL;
 A.b = 1;
 
 b a;
 a.a = 3;
}

在C的环境下，会报错，在C++的情况，这样的操作就是允许的。
在C++的编译器中，允许将结构体名作为一个变量名来对待。

什么是野指针？　　
      一个母亲有两个小孩(两个指针)，一个在厨房，一个在卧室，(属于不同的代码块，其生存期不同)母亲让在厨房的小孩带一块蛋糕(指针指向的对象)给在卧室的小孩，这样在卧室的孩子才肯写作业。但这个在厨房的小孩比较淘气，他在走出厨房时自己将蛋糕吃了，没能带出来。而在卧室的没有吃到蛋糕，所以不肯完成他的作业。结果母亲却不知道卧室的孩子没有吃到蛋糕，还以为作业完了。结果第二天她就被老师召唤到办公室了。事情麻烦了。　　这样，那个在卧室的孩子就是野指针了，因为他没有得到应得的蛋糕，不能完成母亲交给他的作业。
 
      野指针是指那些你已经释放掉的内存指针。当你调用free(p)时，你真正清楚这个动作背后的内容吗？你会说p指向的内存被释放了。没错，p本身有变化吗？答案是p本身没有变化。它指向的内存仍然是有效的，你继续读写p指向的内存，没有人能拦得住你。  
      释放掉的内存会被内存管理器重新分配，此时，野指针指向的内存已经被赋予新的意义。对野指针指向内存的访问，无论是有意还是无意的，都为此会付出巨大代价，因为它造成的后果，如同越界访问一样是不可预料的。 
      释放内存后立即把对应指针置为空值，这是避免野指针常用的方法。这个方法简单有效，只是要注意，当然指针是从函数外层传入的时，在函数内把指针置为空值，对外层的指针没有影响。比如，你在析构函数里把this指针置为空值，没有任何效果，这时应该在函数外层把指针置为空值。




结果是什么？为什么呢？

解释auto_ptr CODE: [Copy to clipboard] #include <iostream> #include <memory> using namespace std; int main() {         auto_ptr<int> pi ( new int(1024) );         cout << *pi << endl;         return 0; } 回答： auto_ptr是C++标准库提供的类模板，它可以帮助程序员自动管理用new表达式动态分配的单个对象。当auto_ptr对象的生命期结束时，动态分配的对象被自动释放。

C＋＋之内存分配

很多人都觉得学习C++是特别困难的事情。C＋＋学习是比较复杂的：它的内存分配、指针、以及面向对象思想的实现等等，确实需要一定的技术积累。我们将以专题的形式，为大家逐一剖析c＋＋的技术重点和难点。     本专题讨论的就是内存分配。学习c＋＋如果不了解内存分配是一件非常可悲的事情。而且，可以这样讲，一个C＋＋程序员无法掌握内存、无法了解内存，是不能够成为一个合格的C＋＋程序员的。     一、内存基本构成     可编程内存在基本上分为这样的几大部分：静态存储区、堆区和栈区。他们的功能不同，对他们使用方式也就不同。     静态存储区：内存在程序编译的时候就已经分配好，这块内存在程序的整个运行期间都存在。它主要存放静态数据、全局数据和常量。     栈区：在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。     堆区：亦称动态内存分配。程序在运行的时候用malloc或new申请任意大小的内存，程序员自己负责在适当的时候用free或delete释放内存。动态内存的生存期可以由我们决定，如果我们不释放内存，程序将在最后才释放掉动态内存。 但是，良好的编程习惯是：如果某动态内存不再使用，需要将其释放掉，否则，我们认为发生了内存泄漏现象。     二、三者之间的区别     我们通过代码段来看看对这样的三部分内存需要怎样的操作和不同，以及应该注意怎样的地方。     例一：静态存储区与栈区 char* p = “Hello World1”; char a[] = “Hello World2”; p[2] = ‘A’; a[2] = ‘A’;   char* p1 = “Hello World1;”     这个程序是有错误的，错误发生在p[2] = ‘A’这行代码处，为什么呢，是变量p和变量数组a都存在于栈区的（任何临时变量都是处于栈区的，包括在main（）函数中定义的变量）。但是，数据“Hello World1”和数据“Hello World2”是存储于不同的区域的。     因为数据“Hello World2”存在于数组中，所以，此数据存储于栈区，对它修改是没有任何问题的。因为指针变量p仅仅能够存储某个存储空间的地址，数据“Hello World1”为字符串常量，所以存储在静态存储区。虽然通过p[2]可以访问到静态存储区中的第三个数据单元，即字符‘l’所在的存储的单元。但是因为数据“Hello World1”为字符串常量，不可以改变，所以在程序运行时，会报告内存错误。并且，如果此时对p和p1输出的时候会发现p和p1里面保存的地址是完全相同的。换句话说，在数据区只保留一份相同的数据（见图1－1）。     例二：栈区与堆区 char*  f1() {    char* p = NULL;    char a;    p = &a;    return p; } char* f2() {    char* p = NULL:    p =(char*)  new  char[4];    return p; }     这两个函数都是将某个存储空间的地址返回，二者有何区别呢？f1()函数虽然返回的是一个存储空间，但是此空间为临时空间。也就是说，此空间只有短暂的生命周期，它的生命周期在函数f1()调用结束时，也就失去了它的生命价值，即：此空间被释放掉。所以，当调用f1()函数时，如果程序中有下面的语句：   char* p ; p = f1(); *p = ‘a’;     此时，编译并不会报告错误，但是在程序运行时，会发生异常错误。因为，你对不应该操作的内存（即，已经释放掉的存储空间）进行了操作。但是，相比之下，f2()函数不会有任何问题。因为，new这个命令是在堆中申请存储空间，一旦申请成功，除非你将其delete或者程序终结，这块内存将一直存在。也可以这样理解，堆内存是共享单元，能够被多个函数共同访问。如果你需要有多个数据返回却苦无办法，堆内存将是一个很好的选择。但是一定要避免下面的事情发生：   void f() {    …    char * p;    p = (char*)new char[100];    … }     这个程序做了一件很无意义并且会带来很大危害的事情。因为，虽然申请了堆内存，p保存了堆内存的首地址。但是，此变量是临时变量，当函数调用结束时p变量消失。也就是说，再也没有变量存储这块堆内存的首地址，我们将永远无法再使用那块堆内存了。但是，这块堆内存却一直标识被你所使用（因为没有到程序结束，你也没有将其delete，所以这块堆内存一直被标识拥有者是当前您的程序），进而其他进程或程序无法使用。我们将这种不道德的“流氓行为”（我们不用，却也不让别人使用）称为内存泄漏。这是我们C++程序员的大忌！！请大家一定要避免这件事情的发生。     总之，对于堆区、栈区和静态存储区它们之间最大的不同在于，栈的生命周期很短暂。但是堆区和静态存储区的生命周期相当于与程序的生命同时存在（如果您不在程序运行中间将堆内存delete的话），我们将这种变量或数据成为全局变量或数据。但是，对于堆区的内存空间使用更加灵活，因为它允许你在不需要它的时候，随时将它释放掉，而静态存储区将一直存在于程序的整个生命周期中。

c++中delete前，判断指针是否为0，有必要吗？ 有必要判断pi = 0吗？ CODE: [Copy to clipboard] if ( pi != 0 )     delete pi; 解答： c++中，如果指针等于0的话，c++不会调用delete的。（因为c++中隐式的进行了判等） 如果显示的判等，那么实际上这个测试会被执行2次。 静态与动态内存分配的两个主要区别： 1. 静态对象是有名字的变量，直接对其进行操作；动态对象是没有名字的变量，通过指针间接地对它们进行操作。 CODE: [Copy to clipboard] int *pia = new int (1024) 分配了一个没有名字int类型的对象，对象初始值是1024。然后，表达式返回对象在内存中的地址。 2. 静态对象的分配和释放由编译器自动处理。动态对象的分配和释放必须由程序员自己显式管理。

试题 4 ：

void GetMemory( char *p )
{
   p = (char *) malloc( 100 );
}

void Test( void )
{
   char *str = NULL;

   GetMemory( str );
   strcpy( str, "hello world" );
   printf( str );
}
试题 5 ：

char *GetMemory( void )
{   
     char p[] = "hello world";      

     return p;  
}
void Test( void )
{   
     char *str = NULL;  

     str = GetMemory();   
     printf( str );   
}

试题 6 ：
void GetMemory( char **p, int num )
{
     *p = (char *) malloc( num );
}
void Test( void )
{
     char *str = NULL;

     GetMemory( &str, 100 );
     strcpy( str, "hello" );
     printf( str );
}

试题 7 ：

void Test( void )
{
     char *str = (char *) malloc( 100 );

     strcpy( str, "hello" );
     free( str );

     ...  // 省略的其它语句

}

解答：

试题 4 传入中 GetMemory( char *p ) 函数的形参为字符串指针，在函数内部修改形参并不能真正的改变传入形参的值，执行完

char *str = NULL;

GetMemory( str );

后的 str 仍然为 NULL ；

试题 5 中

     char p[] = "hello world";   

     return p;  

的 p[] 数组为函数内的局部自动变量，在函数返回后，内存已经被释放。这是许多程序员常犯的错误，其根源在于不理解变量的生存期。
试题 6 的 GetMemory 避免了试题 4 的问题，传入 GetMemory 的参数为字符串指针的指针，但是在 GetMemory 中执行申请内存及赋值语句

p = (char *) malloc( num );

后未判断内存是否申请成功，应加上：

if ( p == NULL )
{

   ...// 进行申请内存失败处理
　 }

试题 7 存在与试题 6 同样的问题，在执行

char *str = (char *) malloc(100);

后未进行内存是否申请成功的判断；另外，在 free(str) 后未置 str 为空，导致可能变成一个 “ 野 ” 指针，应加上：

str = NULL;

试题 6 的 Test 函数中也未对 malloc 的内存进行释放。

剖析：

试题 4 ～ 7 考查面试者对内存操作的理解程度，基本功扎实的面试者一般都能正确的回答其中 50~60 的错误。但是要完全解答正确，却也绝非易事。

对内存操作的考查主要集中在：

（ 1 ）指针的理解；

（ 2 ）变量的生存期及作用范围；

（ 3 ）良好的动态内存申请和释放习惯。

在看看下面的一段程序有什么错误：

swap( int* p1,int* p2 )
{
     int *p;

     *p = *p1;
     *p1 = *p2;
     *p2 = *p;
}

在 swap 函数中， p 是一个 “ 野 ” 指针，有可能指向系统区，导致程序运行的崩溃。在 VC++ 中 DEBUG 运行时提示错误 “Access Violation” 。该程序应该改为：

swap( int* p1,int* p2 )
{
     int p;

     p = *p1;
     *p1 = *p2;
     *p2 = p;
}

试题１：

void test1()
{
   char string[10];
   char* str1 = "0123456789";

     strcpy( string, str1 );
}

试题2：

void test2()
{
   char string[10], str1[10];
     int i;

     for(i=0; i<10; i++)
     {
        str1 = 'a';

     }

     strcpy( string, str1 );
}

试题3：

void test3(char* str1)
{
   char string[10];

   if( strlen( str1 ) <= 10 )
     {
            strcpy( string, str1 );
     }
}

解答：

试题1字符串str1需要11个字节才能存放下（包括末尾的’\0’），而string只有10个字节的空间，strcpy会导致数组越界；

对试题2，如果面试者指出字符数组str1不能在数组内结束可以给3分；如果面试者指出strcpy(string, str1)调用使得从str1内存起复制到string内存起所复制的字节数具有不确定性可以给7分，在此基础上指出库函数strcpy工作方式的给10分；

对试题3，if(strlen(str1) <= 10)应改为if(strlen(str1) < 10)，因为strlen的结果未统计’\0’所占用的1个字节。

剖析：

考查对基本功的掌握：

（1）字符串以’\0’结尾；

（２）对数组越界把握的敏感度；

（３）库函数strcpy的工作方式，如果编写一个标准strcpy函数的总分值为10，下面给出几个不同得分的答案：

2分

void strcpy( char *strDest, char *strSrc )
{
　 while( (*strDest++ = * strSrc++) != ‘\0’ );
}

4分
void strcpy( char *strDest, const char *strSrc )

//将源字符串加const，表明其为输入参数，加2分
{
　 while( (*strDest++ = * strSrc++) != ‘\0’ );
}
7分
void strcpy(char *strDest, const char *strSrc)  
{
//对源地址和目的地址加非0断言，加3分
　assert( (strDest != NULL) && (strSrc != NULL) );

　while( (*strDest++ = * strSrc++)  !=  ‘\0’ );

}
10分

//为了实现链式操作，将目的地址返回，加3分！
char * strcpy( char *strDest, const char *strSrc )  
{
　assert( (strDest != NULL) && (strSrc != NULL) );
char *address = strDest;  

　while( (*strDest++ = * strSrc++) != ‘\0’ );

  return address;
}

类似的我们可以写出一个10分的strlen函数
int strlen( const char *str )    //输入参数const
{
     assert( strt != NULL );    //断言字符串地址非0
     int len;

     while( (*str++) != '\0' )
     {  
            len++;
     }

     return len;

}