随笔 - 7, 文章 - 1, 评论 - 4, 引用 - 0
数据加载中……

2009年8月30日

C/C++ 内存空间分配

一. 在c中分为这几个存储区
1.栈 - 由编译器自动分配释放
2.堆 - 一般由程序员分配释放,若程序员不释放,程序结束时可能由OS回收
3.全局区(静态区),全局变量和静态变量的存储是放在一块的,初始化的全局变量和静态变量在一块区域,未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。- 程序结束释放
4.另外还有一个专门放常量的地方。- 程序结束释放
                                                                                                                                             
在函数体中定义的变量通常是在栈上,用malloc, calloc, realloc等分配内存的函数分配得到的就是在堆上。在所有函数体外定义的是全局量,加了static修饰符后不管在哪里都存放在全局区(静态区),在所有函数体外定义的static变量表示在该文件中有效,不能extern到别的文件用,在函数体内定义的static表示只在该函数体内有效。另外,函数中的"adgfdf"这样的字符串存放在常量区。比如:

int a = 0; //全局初始化区
char *p1; //全局未初始化区
void main()
{
    int b; //栈
    char s[] = "abc"; //栈
    char *p2; //栈
    char *p3 = "123456"; //123456{post.content}在常量区,p3在栈上
    static int c = 0; //全局(静态)初始化区
    p1 = (char *)malloc(10); //分配得来得10字节的区域在堆区
    p2 = (char *)malloc(20); //分配得来得20字节的区域在堆区
    strcpy(p1, "123456");
    //123456{post.content}放在常量区,编译器可能会将它与p3所指向的"123456"优化成一块
}


二.在C++中,内存分成5个区,他们分别是堆、栈、自由存储区、全局/静态存储区和常量存储区
1.栈,就是那些由编译器在需要的时候分配,在不需要的时候自动清楚的变量的存储区。里面的变量通常是局部变量、函数参数等。
2.堆,就是那些由new分配的内存块,他们的释放编译器不去管,由我们的应用程序去控制,一般一个new就要对应一个delete。如果程序员没有释放掉,那么在程序结束后,操作系统会自动回收。
3.自由存储区,就是那些由malloc等分配的内存块,他和堆是十分相似的,不过它是用free来结束自己的生命的。
4.全局/静态存储区,全局变量和静态变量被分配到同一块内存中,在以前的C语言中,全局变量又分为初始化的和未初始化的,在C++里面没有这个区分了,他们共同占用同一块内存区。
5.常量存储区,这是一块比较特殊的存储区,他们里面存放的是常量,不允许修改(当然,你要通过非正当手段也可以修改)

三. 谈谈堆与栈的关系与区别
具体地说,现代计算机(串行执行机制),都直接在代码底层支持栈的数据结构。这体现在,有专门的寄存器指向栈所在的地址,有专门的机器指令完成数据入栈出栈的操作。这种机制的特点是效率高,支持的数据有限,一般是整数,指针,浮点数等系统直接支持的数据类型,并不直接支持其他的数据结构。因为栈的这种特点,对栈的使用在程序中是非常频繁的。对子程序的调用就是直接利用栈完成的。机器的call指令里隐含了把返回地址推入栈,然后跳转至子程序地址的操作,而子程序中的ret指令则隐含从堆栈中弹出返回地址并跳转之的操作。C/C++中的自动变量是直接利用栈的例子,这也就是为什么当函数返回时,该函数的自动变量自动失效的原因。

和栈不同,堆的数据结构并不是由系统(无论是机器系统还是操作系统)支持的,而是由函数库提供的。基本的malloc/realloc/free 函数维护了一套内部的堆数据结构。当程序使用这些函数去获得新的内存空间时,这套函数首先试图从内部堆中寻找可用的内存空间,如果没有可以使用的内存空间,则试图利用系统调用来动态增加程序数据段的内存大小,新分配得到的空间首先被组织进内部堆中去,然后再以适当的形式返回给调用者。当程序释放分配的内存空间时,这片内存空间被返回内部堆结构中,可能会被适当的处理(比如和其他空闲空间合并成更大的空闲空间),以更适合下一次内存分配申请。这套复杂的分配机制实际上相当于一个内存分配的缓冲池(Cache),使用这套机制有如下若干原因:
1. 系统调用可能不支持任意大小的内存分配。有些系统的系统调用只支持固定大小及其倍数的内存请求(按页分配);这样的话对于大量的小内存分类来说会造成浪费。
2. 系统调用申请内存可能是代价昂贵的。系统调用可能涉及用户态和核心态的转换。
3. 没有管理的内存分配在大量复杂内存的分配释放操作下很容易造成内存碎片。

堆和栈的对比
从以上知识可知,栈是系统提供的功能,特点是快速高效,缺点是有限制,数据不灵活;而栈是函数库提供的功能,特点是灵活方便,数据适应面广泛,但是效率有一定降低。栈是系统数据结构,对于进程/线程是唯一的;堆是函数库内部数据结构,不一定唯一。不同堆分配的内存无法互相操作。栈空间分静态分配和动态分配两种。静态分配是编译器完成的,比如自动变量(auto)的分配。动态分配由alloca函数完成。栈的动态分配无需释放(是自动的),也就没有释放函数。为可移植的程序起见,栈的动态分配操作是不被鼓励的!堆空间的分配总是动态的,虽然程序结束时所有的数据空间都会被释放回系统,但是精确的申请内存/ 释放内存匹配是良好程序的基本要素。

    1.碎片问题:对于堆来讲,频繁的new/delete势必会造成内存空间的不连续,从而造成大量的碎片,使程序效率降低。对于栈来讲,则不会存在这个问题,因为栈是先进后出的队列,他们是如此的一一对应,以至于永远都不可能有一个内存块从栈中间弹出,在他弹出之前,在他上面的后进的栈内容已经被弹出,详细的可以>参考数据结构,这里我们就不再一一讨论了。
    2.生长方向:对于堆来讲,生长方向是向上的,也就是向着内存地址增加的方向;对于栈来讲,它的生长方向是向下的,是向着内存地址减小的方向增长。
    3.分配方式:堆都是动态分配的,没有静态分配的堆。栈有2种分配方式:静态分配和动态分配。静态分配是编译器完成的,比如局部变量的分配。动态分配由alloca函数进行分配,但是栈的动态分配和堆是不同的,他的动态分配是由编译器进行释放,无需我们手工实现。
    4.分配效率:栈是机器系统提供的数据结构,计算机会在底层对栈提供支持:分配专门的寄存器存放栈的地址,压栈出栈都有专门的指令执行,这就决定了栈的效率比较高。堆则是C/C++函数库提供的,它的机制是很复杂的,例如为了分配一块内存,库函数会按照一定的算法(具体的算法可以参考数据结构/操作系统)在堆内存中搜索可用的足够大小的空间,如果没有足够大小的空间(可能是由于内存碎片太多),就有可能调用系统功能去增加程序数据段的内存空间,这样就有机会分到足够大小的内存,然后进行返回。显然,堆的效率比栈要低得多。

    明确区分堆与栈:
    在bbs上,堆与栈的区分问题,似乎是一个永恒的话题,由此可见,初学者对此往往是混淆不清的,所以我决定拿他第一个开刀。
    首先,我们举一个例子:

void f()
{
    int* p=new int[5];
}

这条短短的一句话就包含了堆与栈,看到new,我们首先就应该想到,我们分配了一块堆内存,那么指针p呢?他分配的是一块栈内存,所以这句话的意思就是:在栈内存中存放了一个指向一块堆内存的指针p。在程序会先确定在堆中分配内存的大小,然后调用operator new分配内存,然后返回这块内存的首地址,放入栈中,他在VC6下的汇编代码如下:
    00401028    push         14h
    0040102A    call            operator new (00401060)
    0040102F    add           esp,4
    00401032    mov          dword ptr [ebp-8],eax
    00401035    mov          eax,dword ptr [ebp-8]
    00401038    mov          dword ptr [ebp-4],eax
    这里,我们为了简单并没有释放内存,那么该怎么去释放呢?是delete p么?澳,错了,应该是delete []p,这是为了告诉编译器:我删除的是一个数组,VC6就会根据相应的Cookie信息去进行释放内存的工作。
    好了,我们回到我们的主题:堆和栈究竟有什么区别?
    主要的区别由以下几点:
    1、管理方式不同;
    2、空间大小不同;
    3、能否产生碎片不同;
    4、生长方向不同;
    5、分配方式不同;
    6、分配效率不同;
    管理方式:对于栈来讲,是由编译器自动管理,无需我们手工控制;对于堆来说,释放工作由程序员控制,容易产生memory leak。
    空间大小:一般来讲在32位系统下,堆内存可以达到4G的空间,从这个角度来看堆内存几乎是没有什么限制的。但是对于栈来讲,一般都是有一定的空间大小的,例如,在VC6下面,默认的栈空间大小是1M(好像是,记不清楚了)。当然,我们可以修改:
    打开工程,依次操作菜单如下:Project->Setting->Link,在Category 中选中Output,然后在Reserve中设定堆栈的最大值和commit。
注意:reserve最小值为4Byte;commit是保留在虚拟内存的页文件里面,它设置的较大会使栈开辟较大的值,可能增加内存的开销和启动时间。
    堆和栈相比,由于大量new/delete的使用,容易造成大量的内存碎片;由于没有专门的系统支持,效率很低;由于可能引发用户态和核心态的切换,内存的申请,代价变得更加昂贵。所以栈在程序中是应用最广泛的,就算是函数的调用也利用栈去完成,函数调用过程中的参数,返回地址,EBP和局部变量都采用栈的方式存放。所以,我们推荐大家尽量用栈,而不是用堆。

另外对存取效率的比较:
代码:

char s1[] = "aaaaaaaaaaaaaaa";
char *s2 = "bbbbbbbbbbbbbbbbb";
aaaaaaaaaaa是在运行时刻赋值的;
而bbbbbbbbbbb是在编译时就确定的;
但是,在以后的存取中,在栈上的数组比指针所指向的字符串(例如堆)快。
比如:

void main()
{
    char a = 1;
    char c[] = "1234567890";
    char *p ="1234567890";
    a = c[1];
    a = p[1];
    return;
}
对应的汇编代码
10: a = c[1];
00401067 8A 4D F1 mov cl,byte ptr [ebp-0Fh]
0040106A 88 4D FC mov byte ptr [ebp-4],cl
11: a = p[1];
0040106D 8B 55 EC mov edx,dword ptr [ebp-14h]
00401070 8A 42 01 mov al,byte ptr [edx+1]
00401073 88 45 FC mov byte ptr [ebp-4],al
第一种在读取时直接就把字符串中的元素读到寄存器cl中,而第二种则要先把指针值读到edx中,在根据edx读取字符,显然慢了.
    无论是堆还是栈,都要防止越界现象的发生(除非你是故意使其越界),因为越界的结果要么是程序崩溃,要么是摧毁程序的堆、栈结构,产生以想不到的结果,就算是在你的程序运行过程中,没有发生上面的问题,你还是要小心,说不定什么时候就崩掉,编写稳定安全的代码才是最重要的。

static用来控制变量的存储方式和可见性
       函数内部定义的变量,在程序执行到它的定义处时,编译器为它在栈上分配空间,函数在栈上分配的空间在此函数执行结束时会释放掉,这样就产生了一个问题: 如果想将函数中此变量的值保存至下一次调用时,如何实现? 最容易想到的方法是定义一个全局的变量,但定义为一个全局变量有许多缺点,最明显的缺点是破坏了此变量的访问范围(使得在此函数中定义的变量,不仅仅受此 函数控制)。

       需要一个数据对象为整个类而非某个对象服务,同时又力求不破坏类的封装性,即要求此成员隐藏在类的内部,对外不可见。

       static的内部机制:
       静态数据成员要在程序一开始运行时就必须存在。因为函数在程序运行中被调用,所以静态数据成员不能在任何函数内分配空间和初始化。
       这样,它的空间分配有三个可能的地方,一是作为类的外部接口的头文件,那里有类声明;二是类定义的内部实现,那里有类的成员函数定义;三是应用程序的main()函数前的全局数据声明和定义处。
      静态数据成员要实际地分配空间,故不能在类的声明中定义(只能声明数据成员)。类声明只声明一个类的“尺寸和规格”,并不进行实际的内存分配,所以在类声 明中写成定义是错误的。它也不能在头文件中类声明的外部定义,因为那会造成在多个使用该类的源文件中,对其重复定义。
      static被引入以告知编译器,将变量存储在程序的静态存储区而非栈上空间,静态数据成员按定义出现的先后顺序依次初始化,注意静态成员嵌套时,要保证所嵌套的成员已经初始化了。消除时的顺序是初始化的反顺序。

       static的优势:
       可以节省内存,因为它是所有对象所公有的,因此,对多个对象来说,静态数据成员只存储一处,供所有对象共用。静态数据成员的值对每个对象都是一样,但它的 值是可以更新的。只要对静态数据成员的值更新一次,保证所有对象存取更新后的相同的值,这样可以提高时间效率。

        引用静态数据成员时,采用如下格式:
         <类名>::<静态成员名>
    如果静态数据成员的访问权限允许的话(即public的成员),可在程序中,按上述格式
来引用静态数据成员。

       PS:
      (1)类的静态成员函数是属于整个类而非类的对象,所以它没有this指针,这就导致
了它仅能访问类的静态数据和静态成员函数。
      (2)不能将静态成员函数定义为虚函数。
      (3)由于静态成员声明于类中,操作于其外,所以对其取地址操作,就多少有些特殊
,变量地址是指向其数据类型的指针 ,函数地址类型是一个“nonmember函数指针”。

      (4)由于静态成员函数没有this指针,所以就差不多等同于nonmember函数,结果就
产生了一个意想不到的好处:成为一个callback函数,使得我们得以将C++和C-based X W
indow系统结合,同时也成功的应用于线程函数身上。
      (5)static并没有增加程序的时空开销,相反她还缩短了子类对父类静态成员的访问
时间,节省了子类的内存空间。
      (6)静态数据成员在<定义或说明>时前面加关键字static。
      (7)静态数据成员是静态存储的,所以必须对它进行初始化。
      (8)静态成员初始化与一般数据成员初始化不同:
      初始化在类体外进行,而前面不加static,以免与一般静态变量或对象相混淆;
      初始化时不加该成员的访问权限控制符private,public等;
           初始化时使用作用域运算符来标明它所属类;
           所以我们得出静态数据成员初始化的格式:
         <数据类型><类名>::<静态数据成员名>=<值>
      (9)为了防止父类的影响,可以在子类定义一个与父类相同的静态变量,以屏蔽父类的影响。这里有一点需要注意:我们说静态成员为父类和子类共享,但我们有 重复定义了静态成员,这会不会引起错误呢?不会,我们的编译器采用了一种绝妙的手法:name-mangling 用以生成唯一的标志。

补充:new  delete[],基本类型的对象没有析构函数(例如 int , char ),所以回收基本类型组成的数组空间 delete  delete[] 都是应该可以如: int p = new int[10], delete p 和delete[]p 都可 。但是对于类对象数组(如string strArr = new string[10]),只能 delete[]。对 new 的单个对象,只能 delete 不能 delete[] 回收空间 。

posted @ 2009-08-30 18:38 大志 阅读(410) | 评论 (0)编辑 收藏

2009年8月29日

VC++常用设置

   
 

编译参数的设置。主要通过IDE的菜单项Project->Settings->C/C++页来完成。我们可以看到这一页的最下面Project Options中的内容,一般如下:

  /nologo /MDd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_AFXDLL" /D "_M

  BCS" /Fp"Debug/WritingDlgTest.pch" /Yu"stdafx.h" /Fo"Debug/" /Fd"Debug/" /FD /GZ /c

  各个参数代表的意义,可以参考Msdn。比如/nologo表示编译时不在输出窗口显示这些设置(我们可以把这个参数去掉来看看效果)等等。一般我们不会直接修改这些设置,而是通过这一页最上面的Category中的各项来完成。

  1) General:一些总体设置。Warning level用来控制警告信息,其中Level 1是最严重的级别;Warnings as errors将警告信息当作错误处理;Optimizations是代码优化,可以在Category的Optimizations项中进行更细的设置;Generate browse info用以生成.sbr文件,记录类、变量等符号信息,可以在Category的Listing Files项中进行更多的设置。Debug info,生成调试信息:None,不产生任何调试信息(编译比较快);Line Numbers Only,仅生成全局的和外部符号的调试信息到.OBJ文件或.EXE文件,减小目标文件的尺寸;C 7.0- Compatible,记录调试器用到的所有符号信息到.OBJ文件和.EXE文件;Program Database,创建.PDB文件记录所有调试信息;Program Database for "Edit & Continue",创建.PDB文件记录所有调试信息,并且支持调试时编辑。

  2) C++ Language:pointer_to_member representation用来设置类定义/引用的先后关系,一般为Best-Case Always表示在引用类之前该类肯定已经定义了;Enable Exception Handling,进行同步的异常处理;Enable Run-Time Type Information迫使编译器增加代码在运行时进行对象类型检查;Disable Construction Displacements,设置类构造/析构函数调用虚函数问题。

  3) Code Generation:Processor表示代码指令优化,可以为80386、80486、Pentium、Pentium Pro,或者Blend表示混合以上各种优化。Use run-time library用以指定程序运行时使用的运行时库(单线程或多线程,Debug版本或Release版本),有一个原则就是,一个进程不要同时使用几个版本的运行时库。Single-Threaded,静态连接LIBC.LIB库;Debug Single-Threaded,静态连接LIBCD.LIB库;Multithreaded,静态连接LIBCMT.LIB库;Debug Multithreaded,静态连接LIBCMTD.LIB库;Multithreaded DLL,动态连接MSVCRT.DLL库;Debug Multithreaded DLL,动态连接MSVCRTD.DLL库。连接了单线程库就不支持多线程调用,连接了多线程库就要求创建多线程的应用程序。

  Calling convention可以用来设定调用约定,有三种:__cdecl、__fastcall和__stdcall。各种调用约定的主要区别在于,函数调用时,函数的参数是从左到右压入堆栈还是从右到左压入堆栈;在函数返回时,由函数的调用者来清理压入堆栈的参数还是由函数本身来清理;以及在编译时对函数名进行的命名修饰(可以通过Listing Files看到各种命名修饰方式)。Struct member alignment用以指定数据结构中的成员变量在内存中是按几字节对齐的,根据计算机数据总线的位数,不同的对齐方式存取数据的速度不一样。这个参数对数据包网络传输等应用尤为重要,不是存取速度问题,而是数据位的精确定义问题,一般在程序中使用#pragma pack来指定。

  4) Customize:Disable Language Extensions,表示不使用微软为标准C做的语言扩展;Eliminate Duplicate Strings,主要用于字符串优化(将字符串放到缓充池里以节省空间),使用这个参数,使得

  char *sBuffer = "This is a character buffer";

  char *tBuffer = "This is a character buffer";

  sBuffer和tBuffer指向的是同一块内存空间;Enable Function-Level Linking ,告诉编译器将各个函数按打包格式编译;Enables minimal rebuild,通过保存关联信息到.IDB文件,使编译器只对最新类定义改动过的源文件进行重编译,提高编译速度;Enable Incremental Compilation,同样通过.IDB文件保存的信息,只重编译最新改动过的函数;Suppress Startup Banner and Information Messages,用以控制参数是否在output窗口输出。

  5) Listing Files:Generate browse info的功能上面已经提到过。这里可以进行更多的设置。Exclude Local Variables from Browse Info表示是否将局部变量的信息放到.SBR文件中。Listing file type可以设置生成的列表信息文件的内容:Assembly-Only Listing仅生成汇编代码文件(.ASM扩展名);Assembly With Machine Code生成机器代码和汇编代码文件(.COD扩展名);Assembly With Source Code生成源代码和汇编代码文件(.ASM扩展名);Assembly, Machine Code,and Source生成机器码、源代码和汇编代码文件(.COD扩展名)。Listing file name为生成的信息文件的路径,一般为Debug或Release目录下,生成的文件名自动取源文件的文件名。
6) Optimizations:代码优化设置。可以选择Maximize Speed生成最快速的代码,或Minimize Size生成最小尺寸的程序,或者Customize定制优化。定制的内容包括:

  Assume No Aliasing,不使用别名(提高速度);

  Assume Aliasing Across Function Calls,仅函数内部不使用别名;

  Global Optimizations,全局优化,比如经常用到的变量使用寄存器保存,或者循环内的计算优化,如

  i = -100;

  while( i < 0 ){ i += x + y;}

  会被优化为

  i = -100;

  t = x + y;

  while( i < 0 ){i += t;}

  Generate Intrinsic Functions,使用内部函数替换一些函数调用(提高速度);

  Improve Float Consistency,浮点运算方面的优化;

  Favor Small Code,程序(exe或dll)尺寸优化优先于代码速度优化;

  Favor Fast Code,程序(exe或dll)代码速度优化优先于尺寸优化;

  Frame-Pointer Omission,不使用帧指针,以提高函数调用速度;

  Full Optimization,组合了几种参数,以生成最快的程序代码。

  Inline function expansion,内联函数扩展的三种优化(使用内联可以节省函数调用的开销,加快程序速度):Disable不使用内联;Only __inline,仅函数定义前有inline或__inline标记使用内联;Any Suitable,除了inline或__inline标记的函数外,编译器“觉得”应该使用内联的函数,都使用内联。

  7) Precompiled Headers:预编译头文件的设置。使用预编译可以提高重复编译的速度。IDE一般将一些公共的、不大变动的头文件(比如afxwin.h等)集中放到 stdafx.h中,这一部分代码就不必每次都重新编译(除非是Rebuild All)。

  8) Preprocessor:预编译处理。可以定义/解除定义一些常量。Additional include directories,可以指定额外的包含目录,一般是相对于本项目的目录,如..\Include。

  连接参数的设置。主要通过IDE的菜单项Project->Settings->Link页来完成。我们可以看到这一页的最下面Project Options中的内容,一般如下:

  /nologo /subsystem:windows /incremental:yes /pdb:"Debug/WritingDlgTest.pdb" /debug /machi

  ne:I386 /out:"Debug/WritingDlgTest.exe" /pdbtype:sept

  下面我们分别来看一下Category中的各项设置。

  1) General:一些总体设置。可以设置生成的文件路径、文件名;连接的库文件;Generate debug info,生成Debug信息到.PDB文件(具体格式可以在Category->Debug中设置);Ignore All Default Libraries,放弃所有默认的库连接;Link Incrementally,通过生成. ILK文件实现递增式连接以提高后续连接速度,但一般这种方式下生成的文件(EXE或DLL)较大;Generate Mapfile,生成.MAP文件记录模块相关信息;Enable Profiling,这个参数通常与Generate Mapfile参数同时使用,而且如果产生Debug信息的话,不能用.PDB文件,而且必须用Microsoft Format。

  2) Customize:这里可以进行使用程序数据库文件的设置。Force File Output ,强制产生输出文件(EXE或DLL);Print Progress Messages,可以将连接过程中的进度信息输出到Output窗口。

  3) Debug:设置是否生成调试信息,以及调试信息的格式。格式可以有Microsoft Format、COFF Format(Common Object File Format)和Both Formats三种选择;Separate Types,表示将Debug格式信息以独立的.PDB文件存放,还是直接放在各个源文件的.PDB文件中。选中的话,表示采用后者的方式,这种方式调试启动比较快。

  4) Input:这里可以指定要连接的库文件,放弃连接的库文件。还可以增加额外的库文件目录,一般是相对于本项目的目录,如..\Lib。Force Symbol References,可以指定连接特定符号定义的库。

  5) Output:Base Address可以改变程序默认的基地址(EXE文件默认为0x400000,DLL默认为x10000000),操作系统装载一个程序时总是试着先从这个基地址开始。Entry-Point Symbol可以指定程序的入口地址,一般为一个函数名(且必须采用__stdcall调用约定)。一般Win32的程序,EXE的入口为 WinMain,DLL的入口为DllEntryPoint;最好让连接器自动设置程序的入口点。默认情况下,通过一个C的运行时库函数来实现:控制台程序采用mainCRTStartup (或wmainCRTStartup)去调用程序的main (或wmain)函数;Windows程序采用WinMainCRTStartup (或 wWinMainCRTStartup)调用程序的WinMain (或 wWinMain,必须采用__stdcall调用约定);DLL采用_DllMainCRTStartup调用DllMain函数(必须采用 __stdcall调用约定)。Stack allocations,用以设置程序使用的堆栈大小(请使用十进制),默认为1兆字节。Version Information告诉连接器在EXE或DLL文件的开始部分放上版本号。

值得注意的是,上面各个参数是大小写敏感的;在参数后加上“-”表示该参数无效;各个参数值选项

  有“*”的表示为该参数的默认值;可以使用页右上角的“Reset”按钮来恢复该页的所有默认设置。

  其它一些参数设置

  1) Project->Settings->General,可以设置连接MFC库的方式(静态或动态)。如果是动态连

  接,在你的软件发布时不要忘了带上MFC的DLL。

  2) Project->Settings->Debug,可以设置调试时运行的可执行文件,以及命令行参数等。

  3) Project->Settings->Custom Build,可以设置编译/连接成功后自动执行一些操作。比较有

  用的是,写COM时希望IDE对编译通过的COM文件自动注册,可以如下设置:

  Description: Register COM

  Commands: regsvr32 /s /c $(TargetPath)

  echo regsvr32 exe.time > $(TargetDir)\$(TargetName).trg

  Outputs: $(TargetDir)\$(TargetName).trg

  4) Tools->Options->Directories,设置系统的Include、Library路径。

  一些小窍门(针对Visual C++)

  1) 有时候,你可能在编译的时候,计算机突然非法关机了(可能某人不小心碰了电源或你的内存不稳定等原因)。当你重启机器后打开刚才的项目,重新进行编译,发现IDE会崩掉。你或许以为你的编译器坏了,其实不然(你试试编译其它项目,还是好的!),你只要将项目的.ncb、.opt、.aps、.clw文件以及Debug、Release目录下的所有文件都删掉,然后重新编译就行了。

  2) 如果你想与别人共享你的源代码项目,但是把整个项目做拷贝又太大。你完全可以删掉以下文件:.dsw、.ncb、.opt、.aps、.clw、. plg文件以及Debug、Release目录下的所有文件。

  3) 当你的Workspace中包含多个Project的时候,你可能不能直观地、一眼看出来哪个是当前项目。可以如下设置:Tools->Options->Format,然后在Category中选择Workspace window,改变其默认的字体(比如设成Fixedsys)就行了。

  4) 如何给已有的Project改名字?将该Project关掉。然后以文本格式打开.dsp文件,替换原来的Project名字即可。

  5) VC6对类成员的智能提示功能很有用,但有时候会失灵。你可以先关掉项目,将.clw和.ncb删掉,然后重新打开项目,点击菜单项 View->ClassWizard,在弹出的对话框中按一下“Add All”按钮;重新Rebuild All。应该可以解决问题。

posted @ 2009-08-29 15:32 大志 阅读(248) | 评论 (0)编辑 收藏

2008年11月28日

c#里的string.compare 问题

    以前一直以为所有语言的字符串比较都是逐个字符比较,比较ASCII码或者UNICODE码值,例如string.compare("21sea","21SEA")= -1 ,原以为是s和S决定了字符串的比较值,在后面添加字符时,不会改变结果,即:string.compare("21sea22","21SEA21") 仍然等于-1,然而在c#中输出结果为1。
    原来在字符串的排序中是有第三个参数的,他决定了字符串的比较规则。在c#的字符串比较中对字母字符、非字母字符的数字或者一些符号赋予了不同的权重。在.NET Framework 中有三种排序方式,单词排序、字符串排序和序号排序。单词排序执行区分区域性的字符串比较。某些非字母数字字符可能被赋予了特殊权重。例如,连字符(“-”)的权重非常小,因此“coop”和“co-op”在排序列表中是紧挨着出现的。字符串排序与单词排序类似,只不过它没有特殊情况。因此,所有非字母数字符号会排在所有字母数字字符之前。而序号排序基于字符串中各元素的 Unicode 值对字符串进行比较。

posted @ 2008-11-28 22:35 大志 阅读(964) | 评论 (0)编辑 收藏

2008年9月26日

c#文件流读取编码问题(转)

C#解决读写包含汉字的txt文件时乱码的问题
[日期:2005-08-09] 来源:CSDN  作者:袁晓辉 [字体:大 中 小] 

   当我们用System.IO.StreamReader读取包含汉字的txt文件时,经常会读出乱码(StreamWriater写文本文件也
有类似的问题),原因很简单,就是文件的编码(encoding)和StreamReader/Writer的encoding不对应。

    为了解决这个问题,我写了一个类,来取得一个文本文件的encoding,这样我们就可以创建对应的

StreamReader和StreamWriter来读写,保证不会出现乱码现象。其实原理很简单,文本编辑器(比如XP自带的记事

本)在生成文本文件时,如果编码格式和系统默认的编码(中文系统下默认为GB2312)不一致时,会在txt文件开头

部分添加特定的“编码字节序标识(Encoding Bit Order Madk,简写为BOM)”,类似PE格式的"MZ"文件头。这样

它在读取时就可以根据这个BOM来确定该文本文件生成时所使用的Encoding。这个BOM我们用记事本等程序打开默认

是看不到的,但是用stream按字节读取时是可以读到的。我的这个TxtFileEncoding类就是根据这个BOM“文件头”

来确定txt文件生成时用到的编码的。

//  作者:袁晓辉
//  2005-8-8
// // // // // //
using System;
using System.Text;
using System.IO;
namespace Farproc.Text
{
    /// <summary>
    /// 用于取得一个文本文件的编码方式(Encoding)。
    /// </summary>
    public class TxtFileEncoding
    {
        public TxtFileEncoding()
        {
            //
            // TODO: 在此处添加构造函数逻辑
            //
        }
        /// <summary>
        /// 取得一个文本文件的编码方式。如果无法在文件头部找到有效的前导符,Encoding.Default将被返回。
        /// </summary>
        /// <param name="fileName">文件名。</param>
        /// <returns></returns>
        public static Encoding GetEncoding(string fileName)
        {
            return GetEncoding(fileName, Encoding.Default);
        }
        /// <summary>
        /// 取得一个文本文件流的编码方式。
        /// </summary>
        /// <param name="stream">文本文件流。</param>
        /// <returns></returns>
        public static Encoding GetEncoding(FileStream stream)
        {
            return GetEncoding(stream, Encoding.Default);
        }
        /// <summary>
        /// 取得一个文本文件的编码方式。
        /// </summary>
        /// <param name="fileName">文件名。</param>
        /// <param name="defaultEncoding">默认编码方式。当该方法无法从文件的头部取得有效的前导符时,将返回该编码方式。</param>
        /// <returns></returns>
        public static Encoding GetEncoding(string fileName, Encoding defaultEncoding)
        {
            FileStream fs = new FileStream(fileName, FileMode.Open);
            Encoding targetEncoding = GetEncoding(fs, defaultEncoding);
            fs.Close();
            return targetEncoding;
        }
        /// <summary>
        /// 取得一个文本文件流的编码方式。
        /// </summary>
        /// <param name="stream">文本文件流。</param>
        /// <param name="defaultEncoding">默认编码方式。当该方法无法从文件的头部取得有效的前导符时,将返回该编码方式。</param>
        /// <returns></returns>
        public static Encoding GetEncoding(FileStream stream, Encoding defaultEncoding)
        {
            Encoding targetEncoding = defaultEncoding;
            if(stream != null && stream.Length >= 2)
            {
                //保存文件流的前4个字节
                byte byte1 = 0;
                byte byte2 = 0;
                byte byte3 = 0;
                byte byte4 = 0;
                //保存当前Seek位置
                long origPos = stream.Seek(0, SeekOrigin.Begin);
                stream.Seek(0, SeekOrigin.Begin);
               
                int nByte = stream.ReadByte();
                byte1 = Convert.ToByte(nByte);
                byte2 = Convert.ToByte(stream.ReadByte());
                if(stream.Length >= 3)
                {
                    byte3 = Convert.ToByte(stream.ReadByte());
                }
                if(stream.Length >= 4)
                {
                    byte4 = Convert.ToByte(stream.ReadByte());
                }
                //根据文件流的前4个字节判断Encoding
                //Unicode {0xFF, 0xFE};
                //BE-Unicode {0xFE, 0xFF};
                //UTF8 = {0xEF, 0xBB, 0xBF};
                if(byte1 == 0xFE && byte2 == 0xFF)//UnicodeBe
                {
                    targetEncoding = Encoding.BigEndianUnicode;
                }
                if(byte1 == 0xFF && byte2 == 0xFE && byte3 != 0xFF)//Unicode
                {
                    targetEncoding = Encoding.Unicode;
                }
                if(byte1 == 0xEF && byte2 == 0xBB && byte3 == 0xBF)//UTF8
                {
                    targetEncoding = Encoding.UTF8;
                }
                //恢复Seek位置      
                stream.Seek(origPos, SeekOrigin.Begin);
            }
            return targetEncoding;
        }
    }
}
    由于在GB2312和UTF7编码都没有BOM,所以需要指定一个默认的Encoding,在找不到合法的BOM时,将返回这个

Encoding。有谁知道如何区分GB2312和UTF7编码txt文件的方法,也请告诉我。

    由于只是static方法,所以不用new,直接通过类名调用方法,使用起来也很简单。

using System;
using Farproc.Text;
using System.Text;
using System.IO;
namespace ConsoleApplication1
{
    /// <summary>
    /// Class1 的摘要说明。
    /// </summary>
    class Class1
    {
        /// <summary>
        /// 应用程序的主入口点。
        /// </summary>
        [STAThread]
        static void Main(string[] args)
        {
            //
            // TODO: 在此处添加代码以启动应用程序
            //
            string fileName = @"e:\a.txt";
            //生成一个big endian Unicode编码格式的文本文件
            StreamWriter sw = new StreamWriter(fileName, false, Encoding.BigEndianUnicode);//你可以试试其他编码,比如Encoding.GetEncoding("GB2312")或UTF8
            sw.Write("这是一个String");
            sw.Close();

            //读取
            Encoding fileEncoding = TxtFileEncoding.GetEncoding(fileName, Encoding.GetEncoding("GB2312"));//取得这txt文件的编码
            Console.WriteLine("这个文本文件的编码为:" + fileEncoding.EncodingName);
            StreamReader sr = new StreamReader(fileName, fileEncoding);//用该编码创建StreamReader

            //用下面的方法虽然可以让系统自动判断文本文件的编码格式,但是我们无法取得该文本文件的编码
            //sr.CurrentEncoding永远为 Unicode(UTF-8)
            //StreamReader sr = new StreamReader(fileName, true);
            //Console.WriteLine("这个文本文件的编码为:" + sr.CurrentEncoding.EncodingName);
            Console.WriteLine("这个文本文件的内容为:" + sr.ReadToEnd());
            sr.Close();
            Console.ReadLine();
        }
    }
}

    .NET下的string永远是Unicode的,所以只能判断txt文件的Encoding。对于byte[],只有自己知道它的

Encoding才能转换为string 转换为其他编码的byte[],一个例外是把整个txt文件通过stream读入byte[]后也可以根据它的前几个字节判断

Encoding,对于片断,我们就无能为力了:)

posted @ 2008-09-26 19:10 大志 阅读(8415) | 评论 (3)编辑 收藏

CFileFind类的使用总结(转)

CFileFind类的使用总结
2007-7-7
1、CFileFind类的声明文件保存在afx.h头文件中。
2、该类的实现的功能:执行本地文件的查找(查找某个具体的文件,查找某类文件x*.x*,查找所有文件*.*)
3、CFileFind类是CGopherFileFind和CFtpFileFind类的基类。
4、CFileFind类的构造函数::CFileFind()和关闭函数::Close()我会成对使用。
5、CFileFind类的成员函数我根据其操作特性划分为3类:查找操作类、获得文件属性类、判断文件属性类。(下面我先进行函数罗列并没有完整的描述函数的参数)
查找操作类
      ::FindFile();
      ::FindNextFile();
获得文件属性类
      ::GetCreationTime();
      ::GetLastAccessTime();
      ::GetLastWriteTime();
::GetFileName();
::GetRoot();
      ::GetFilePath();
      ::GetFileTitle();
      ::GetFileURL();
      ::GetLength();
     
判断文件属性类
      ::IsArchived();
      ::IsCompressed();
      ::IsDirectory();
      ::IsDots();
      ::IsHidden();
      ::IsNormal();
      ::IsReadOnly();
      ::IsSystem();
      ::IsTemporary();
      ::MatchesMask();
6、CFileFind类中成员函数使用应注意的顺序
      在创建了CFileFind对象后,先执行::FindFile()函数,然后执行::FindNextFile(),然后选择执行(获得文件属性类)的函数或者(判断文件属性类)函数。
7、CFileFind类成员函数的详细分析
virtual BOOL FindFile(LPCTSTR pstrName = null,DWORD dwUnused = 0);
该函数若返回非0 则表明执行成功,0 则表明执行不成功。
pstrName:需要查找的文件名,例:“E:\\编程工具\\VC++\\MFC例子.rar”,“E:\\编程工具\\VC++\\MFC*.rar”,“E:\\编程工具\\VC++\\*.*”,也可以是NULL表示“*.*”。
dwUnused:必须为0
 
virtual BOOL FindNextFile();
该函数返回值非0 还有符合条件的文件, 0表示是最后一个文件。
 
virtual BOOL GetCreationTime(FILETIME *pFileTime) const;
virtual BOOL GetCreationTime(CTime& refTime) const;
该函数用来获得查找到的某个文件的创建时间,返回值非0 获得创建时间成功操作,0表示执行获得创建时间失败或者FindNextFile()没有被执行的时候。
FILETIME  *:容纳时间的结构指针
CTime&:容纳时间的对象地址
此处介绍:FILETIME和CTime相互转换的处理方法:
FILETIME转CTime的方法:
A、CTime对象在初始化时可以传递FILETIME结构
      FILETIME ft;
      CTime time(ft);
B、将FILETIME转换为SYSTEMTIME,然后CTime对象在初始化时可以传递SYSTEMTIME结构
      FILETIME ft;
      SYSTEMTIME st;
      BOOL bSuccess = ::FileTimeToSystemTime(&ft , &st);
      CTime time(st);
CTime转FILETIME方法:
CTime time(CTime::GetCurrentTime());
SYSTEMTIME st;
time.GetAsSystemTime(st);
FILETIME ft;
::SystemTimeToFileTime(&st,&ft);
 
virtual BOOL GetLastAccessTime(FILETIME *pFileTime) const;
virtual BOOL GetLastAccessTime(CTime& refTime) const;
该函数用来获得某个文件最后被访问的时间,非0表示执行成功,0表示执行失败或者FindNextFile()函数没有执行的时候。
 
virtual BOOL GetLastWriteTime(FILETIME *pFileTime) const;
virtual BOOL GetLastWriteTime(CTime& refTime) const;
该函数用来获得某个文件最后被访问的时间,非0表示执行成功,0表示执行失败或者FindNextFile()函数没有执行的时候。
 
virtual CString GetFilePath() const;
该函数用来获得查找到的文件绝对路径,必须在执行了FindNextFile()后该函数才能执行成功。
返回的结果是CString对象,例“E:\\编程工具\\VC++\\MFC.rar
 
virtual CString GetFileName() const;
该函数用来获得查找到的文件的全称,必须在执行了FindNextFile()后该函数才能执行成功。
返回的结果是CString对象,例“MFC.rar”
 
virtual CString GetFileTitle() const;
该函数用来获得查找到的文件的名称,必须在执行了FindNextFile()后该函数才能执行成功。
返回的结果是CString对象,例“MFC”
 
virtual CString GetRoot() const;
该函数用来获得查找到的文件的根目录,必须在执行了FindNextFile()后该函数才能执行成功。
返回的结果是CString对象,例“E:\\编程工具\\VC++\\
 
virtual CString GetFileURL() const;
该函数用来获得查找到的文件的URL路径,必须在执行了FindNextFile()后该函数才能执行成功。
返回的结果是CString对象,例“file://E:\\编程工具\\VC++\\MFC.rar
 
DWORD GetLength() const;
该函数返回值获得查找到的文件的长度,必须在执行了FindNextFile()后该函数才能执行成功。
 
BOOL IsArchived() const;
该函数用来判断查找的文件属性是否是档案文件,非0表示是,0表示不是。必须在执行了FindNextFile()后该函数才能执行成功
 
BOOL  IsCompressed() const;
该函数用来判断查找的文件属性是否是压缩文件,非0表示是,0表示不是。必须在执行了FindNextFile()后该函数才能执行成功
 
BOOL IsDirectory() const;
该函数用来判断查找的文件属性是否是路径文件,非0表示是,0表示不是。必须在执行了FindNextFile()后该函数才能执行成功
 
BOOL IsDots() const;
该函数用来判断查找的文件属性是否是“.”,“..”,非0表示是,0表示不是。必须在执行了FindNextFile()后该函数才能执行成功
 
BOOL IsHidden() const;
该函数用来判断查找的文件属性是否隐藏文件,非0表示是,0表示不是。必须在执行了FindNextFile()后该函数才能执行成功
 
BOOL IsNormal() const;
该函数用来判断查找的文件属性是否正常文件,非0表示是,0表示不是。必须在执行了FindNextFile()后该函数才能执行成功
 
BOOL IsReadOnly() const;
该函数用来判断查找的文件属性是否只读文件,非0表示是,0表示不是。必须在执行了FindNextFile()后该函数才能执行成功
 
BOOL IsSystem() const;
该函数用来判断查找的文件属性是否系统文件,非0表示是,0表示不是。必须在执行了FindNextFile()后该函数才能执行成功
 
BOOL IsTemporary() const;
该函数用来判断查找的文件属性是否临时文件,非0表示是,0表示不是。必须在执行了FindNextFile()后该函数才能执行成功
 
BOOL MatchesMask(DWORD dwMask) const;
该函数用来判断查找的文件的综合属性,非0表示是,0表示不是。必须在执行了FindNextFile()后该函数才能执行成功
dwMask参数的使用方法:几种文件属性采用或运算(|)
文件属性的结构定义:
      FILE_ATTRIBUTE_ARCHIVE:档案文件
      FILE_ATTRIBUTE_COMPRESSED:压缩文件
      FILE_ATTRIBUTE_DIRECTORY:路径文件
      FILE_ATTRIBUTE_NORMAL:正常文件
      FILE_ATTRIBUTE_READONLY:只读文件
      FILE_ATTRIBUTE_SYSTEM:系统文件
      FILE_ATTRIBUTE_TEMPORARY:临时文件
      FILE_ATTRIBUTE_HIDDEN:隐藏文件
 

 
 原文地址 http://blog.csdn.net/dodream/archive/2007/07/10/1684446.aspx 

posted @ 2008-09-26 09:32 大志 阅读(622) | 评论 (0)编辑 收藏

2008年9月24日

几个学c++的网址

www.royaloo.com

www.shubulo.com

posted @ 2008-09-24 07:13 大志 阅读(153) | 评论 (0)编辑 收藏

2008年9月23日

自己写的正向最大匹配分词

      最近闲的没什么事,花了好长时间写了一个正向最大匹配程序,由于自己在写程序上是一个菜鸟,望看到此程序的见谅!

#include<iostream>
#include
<fstream>
#include
<string>
#include
<vector>
#include
<algorithm>

using namespace std;

int main()
{
    ifstream infile;
    infile.open(
"C:\\Documents and Settings\\dazhi\\桌面\\dict.txt");
    vector
<string>  ChDic;
    
string word;
    
string text="党中央和国务院";
    vector
<string>arr;
    
//load dict 
    while(getline(infile,word ))
    
{         
       ChDic.push_back(word);         
    }
   
    
    
string temp = text; 
    
string temp1 = temp;
   
int p1 = 0
  
while(strlen(temp1.c_str())!=0)
   

     
for(int i=strlen(temp1.c_str());i>=0;i=i-2)
    
{
       
if(find(ChDic.begin(),ChDic.end(),temp)!=ChDic.end())
        
{
         temp 
+="|";       
         arr.push_back(temp);
         p1 
= i ;                               
         
break;
        }
              
      
else
       
{
         temp 
= temp1.substr(0,i-2);   
       }
          
    }
  
      temp1 
= temp1.substr(p1); 
      temp 
= temp1;
    
   }

    
for(vector<string>::iterator iter=arr.begin();iter!=arr.end();++iter)
    
{
       cout 
<<*iter;
    }
 
    cout 
<<endl;
    infile.close();
    system(
"pause");
}

posted @ 2008-09-23 21:29 大志 阅读(1012) | 评论 (1)编辑 收藏