亚洲性久久久影院,国内精品伊人久久久久妇,国产综合久久久久

关于C++�c�d��const函数

Sun, 28 Oct 2007 18:52:00 GMT

据说有这�U�面试题�Q?br />class A
{
        public :
        char get_m() const
        {
                 return m;
        }
        private:
        char m;
}
请在函数get_m中改变m的倹{�?br />
我想�Q�对于这�U�流氓问题，只好使用��氓的做法：
        char get_m() const
        {
                char * p = (char *) &m;
                *p = 'C';
                 return m;
        }
呵呵�Q�可以做刎ͼ�因�ؓ�c�d��const函数是通过“把�c�d��成员都作为const”来实现的�?br />不过�q�是我这�U�“流氓程序员”的做法�?br />
实际上，�l�过同事的教��|��应该使用mutable修饰�W�：
mutable char m;
�q�样即��在类的const函数内，m的类型也是可以改变的了�?br />
另外�Q�如果想不要�q�䆾工作�Q�也可以�q�么写：
#define const
哈哈�Q�这样面试官��׃��敢要你啦�?D

旅�?/a> 2007-10-29 02:52 发表评论

const成员函数

Sun, 28 Oct 2007 18:49:00 GMT

�W�五节　const成员函数

一些成员函数改变对象，一些成员函��C��改变对象�?

例如�Q?
int Point::GetY()
{
　 return yVal;
}
　　 �q�个函数被调用时�Q�不改变Point对象�Q�而下面的函数改变Point对象�Q?
void Point:: SetPt (int x, int y)
{
　 xVal=x;
　 yVal=y;
}
　　 ��Z��使成员函数的意义更加清楚�Q�我们可在不改变对象的成员函数的函数原型中加上const说明�Q?


	�?0-15
	class Point { 　 public: 　　 int GetX() const; 　　 int GetY() const; 　　void SetPt (int, int); 　　 void OffsetPt (int, int); 　 private: 　　 int xVal, yVal; };

　　 const成员函数应该在函数原型说明和函数定义中都增加const限定�Q?


	�?0-16
	int Point::GetY() const { 　 return yVal; } class Set { public: 　 Set (void){ card = 0; } 　 bool Member(const int) const; 　 void AddElem(const int); 　 //... }; bool Set::Member (const int elem) const { 　 //... }

非常量成员函��C��能被帔R��成员对象调用�Q�因为它可能企图修改帔R��的数据成员：
　　 const Set s;
　　 s.AddElem(10); // 非法: AddElem不是帔R��成员函数
　　 s.Member(10); // 正确
　　但构造函数和析构函数对这个规则例外，它们从不定义为常量成员，但可被常量对象调用（被自动调用）。它们也能给帔R��的数据成员赋��|��除非数据成员本��n是常量�?/p> 　　

��Z��么需要const成员函数�Q?
　　我们定义的类的成员函��C��Q�常常有一些成员函��C��改变�cȝ��数据成员�Q�也��是��_��q�些函数�?只读"函数�Q�而有一些函数要修改�c�L��据成员的倹{��如果把不改�? 数据成员的函数都加上const关键字进行标识，昄��Q�可提高�E�序的可��L��。其实，它还能提高程序的可靠性，已定义成const的成员函敎ͼ�一旦企图修�? 数据成员的��|��则编译器按错误处理�?/span>
const成员函数和const对象
　　实际上，const成员函数�q�有另外一��作用，卛_��量对象相兟뀂对于内�|�的数据�c�d��Q�我们可以定义它们的帔R��Q�用戯��定义的类也一��P��可以定义它们的常量对象。例如，定义一个整型常量的�Ҏ��为：
　　 const int i=1 �Q?
同样�Q�也可以定义帔R��对象�Q�假定有一个类classA�Q�定义该�cȝ��帔R��对象的方法�ؓ�Q?
　　 const classA a(2)�Q?
　　 �q�里�Q�a是类classA的一个const对象�Q?2"传给它的构造函数参数。const对象的数据成员在对象寿命期内不能改变。但是，如何保证该类的数据成员不被改变呢�Q?
　　 ��Z��保const对象的数据成员不会被改变�Q�在C++中，const对象只能调用const成员函数。如果一个成员函数实际上没有�Ҏ��据成员作��M��形式的修改，但是它没有被const关键字限定的�Q�也不能被常量对象调用。下面通过一个例子来说明�q�个问题�Q?


	�?0-17
	class C { 　 int X; public: 　 int GetX() 　 { 　　 return X; 　 } 　 void SetX(int X) 　 { 　　 this->X = X; 　 } }; void main() { 　 const C constC; 　 cout< }

如果我们�~�译上面的程序代码，�~�译器会出现错误提示�Q�constC是个帔R��对象�Q�它只能调用const成员函数。虽然GetX( )函数实际上�ƈ没有改变数据成员X�Q�由于没有const关键字限定，所以仍旧不能被constC对象调用。如果我们将上述加粗的代码：
　　 int GetX()
改写成：
　　 int GetX()const
再重新编译，��没有问题了�?/span>

　　 const成员函数的��?
　　 const成员函数表示该成员函数只能读�c�L��据成员，而不能修改类成员数据。定义const成员函数�Ӟ��把const关键字放在函数的参数表和函数体之间。有人可能会问：��Z��么不��const攑֜�函数声明前呢�Q�因��样做意味着函数的返回值是帔R��Q�意义完全不同。下面是定义const成员函数的一个实例：
　　 class X
　　 {
　　　 int i;
　　　 public:
　　　 int f() const;
　　 };
　　关键字const必须用同��L��方式重复出现在函数实现里�Q�否则编译器会把它看成一个不同的函数�Q?
　　 int X::f() const
　　 {
　　　 return i;
　　 }
　　如果f( )试图用�Q何方式改变i或调用另一个非const成员函数�Q�编译器��给出错误信息。�Q何不修改成员数据的函数都应该声明为const函数�Q�这��h��助于提高�E�序的可��L��和可靠性�?/font>

旅�?/a> 2007-10-29 02:49 发表评论

Sun, 28 Oct 2007 18:41:00 GMT

#include
//using namespace std;
class A{
public:
   int i;
   A(int m)
   {
       i=m;
   cout<   }
   ~A()
   {
   cout<   }
};
A a(0);
int main()
{
   cout<<"main"<A b(1);
static A c(2);
cout<<"unmain"<}
0 A con
main
1 A con
2 A con
unmain
1 A des
2 A des
0 A des

#include
//using namespace std;
class A{
public:
    int i;
    A(int m)
    {
        i=m;
    cout<    }
    ~A()
    {
    cout<    }
};
A a(0);
int main()
{
    cout<<"main"<A b(1);
A c(2);
cout<<"unmain"<}

0 A con
main
1 A con
2 A con
3 A con
unmain
2 A des
1 A des
3 A des
0 A des

旅�?/a> 2007-10-29 02:41 发表评论

Sun, 28 Oct 2007 18:31:00 GMT

今天在测试一个构造函数和析构函数的用例的时候，发现我们所钟爱的VC6.0实在是Bug问题��来��多�Q�对于学习C++的新手来�Ԍ��有必要在�q�里�l�大家说明一下�?/span>

构造函数顺序�ؓ�Q?/p>

全局对象的构造函敎ͼ�
main函数中对象的构造函敎ͼ�包括automatic、static依次调用�Q?
main中遇到函��C��有局部对象时�Q�进入到函数中调用局部对象的构造函数�?/span>

注：static对象的构造函数永�q�只调用一�ơ�?/span>

析构函数��序为：

退出函数时�Q�执行函数内构造的automatic对象的析构函敎ͼ�注：static对象不析构；
main函数中按构造的逆序析构automatic对象�Q?
调用函数中定义的static对象的析构函敎ͼ�
调用main中定义的static对象的析构函敎ͼ�
最后调用全局对象的析构函数�?/span>

注：复合中的构造、析构顺�?/span>

构造：按声明对象的��序来构造成员对象，而不是按照构造函数成员初始值列表中列出的顺序；而且在包含它们的�c�d��?宿主对象)被构造之前构造。即�Q�由内向外构造�?/span>

析构�Q�按对象构造的逆序析构。对于复合对象，先析构主对象�Q�再析构其包含的对象�?/span>

比如有以下的��试用例�Q?/span>

//�Q�i nclude
�Q�i nclude
using namespace std;
class Demo {
int id;
public:
Demo(int i)
{ id = i;
cout << "id=" << id << ",Con" << endl; }
~Demo()
{ cout << "id=" << id << ",Des" <};

Demo d1(4);

void fun(Demo d) {
static Demo d2(2);
Demo d3(3);
cout << "fun" << endl;
}
void main () {
cout <<"main"<< endl;
fun(d1);
cout << "endmain" << endl;
fun(d1);
Demo * p = new Demo(8);

}

�E�序执行的时候，在VC6 withSp6下运行的�l�果

id=4,Con

main

id=2,Con

id=3,Con

fun

id=3,Des

id=4,Des

endmain

id=3,Con

fun

id=3,Des

id=4,Des

id=8,Con

id=2,Des

//id=4,Des //在用的时候才有此句输�?/span>

其中包含有注释的部分�Q��ؓ调整包含的头文�g�?lt;iostream.h>的情况下才有的输出。如果��?命名�I�间的std的话�Q�没有最后的一句输出�?/span>

从百度上找了半天�Q�才发现不是没有调用全局变量的析构函敎ͼ�而是因�ؓ我们所用的�~�译器有问题�Q�这是MS的��品对于C++的支持做的不是尽善尽��，有网友说在Vc7.0中好��x��除了�q�个Bug�?/span>

旅�?/a> 2007-10-29 02:31 发表评论

头文�? extern

Sun, 28 Oct 2007 18:02:00 GMT

　　试题4�Q��ؓ什么标准头文�g都有�c�M��以下的结构？

#ifndef __INCvxWorksh
#define __INCvxWorksh
#ifdef __cplusplus

extern "C" {
#endif
/*...*/
#ifdef __cplusplus
}

#endif
#endif /* __INCvxWorksh */

　　解答�Q?br />
　　头文件中的编译宏

#ifndef　__INCvxWorksh
#define　__INCvxWorksh
#endif

　　的作用是防止被重复引用�?br />
　　作�ؓ一�U�面向对象的语言�Q�C++支持函数重蝲�Q�而过�E�式语言C则不支持。函数被C++�~�译后在symbol库中的名字与C语言的不同。例如，假设某个函数的原型�ؓ�Q?

void foo(int x, int y);

　　该函数被C�~�译器编译后在symbol库中的名字�ؓ_foo�Q�而C++�~�译器则会��生像_foo_int_int之类的名字。_foo_int_int�q�样的名字包含了函数名和函数参数数量及类型信息，C++��是考这�U�机制来实现函数重蝲的�?br />
　　��Z��实现C和C++的�؜合编�E�，C++提供了C�q�接交换指定�W�号extern "C"来解军_��字匹配问题，函数声明前加上extern "C"后，则编译器��׃��按照C语言的方式将该函数编译�ؓ_foo�Q�这样C语言中就可以调用C++的函��C��?/p>

旅�?/a> 2007-10-29 02:02 发表评论

Sun, 28 Oct 2007 17:46:00 GMT

一�Q�在�|�上扑ֈ�了BOOL和bool的区别：
1、类型不�?br />BOOL为int�?br />bool为布��型
2、长度不�?br />bool只有一个字�?br />BOOL长度视实际环境来定，一般可认�ؓ�?个字�?br />3、取��g��?br />bool取值false和true�Q�是0�?的区�?br />BOOL取值FALSE和TRUE�Q�是0和非0的区�?br />二：
bool是标准C++数据�c�d��Q�可取值true和false。单独占一个字节，
如果��C��bool对象列在一��P��可能会各占一个bit�Q�这取决于编译器�?br />
BOOL是微软定义的typedef int BOOL。与bool不同�Q�它是一个三值逻辑

�Q?br />TRUE/FALSE/ERROR�Q�返回��gؓ>0的整��CؓTRUE�Q?为FALSE�Q?1为ERROR�?br />Win32 API中很多返回��gؓBOOL的函数都是三值逻辑。比如GetMessage

().
三：
大BOOL和小bool之间的区别：
1、类型不�?br />BOOL为int�?br />bool为布��型
2、长度不�?br />bool只有一个字�?br />BOOL长度视实际环境来定，一般可认�ؓ�?个字�?br />3、取��g��?br />bool取值false和true�Q�是0�?的区�?br />BOOL取值FALSE和TRUE�Q�是0和非0的区�?br />4、例�?br />bool x=3; //告警
bool x=1; //正确
BOOL x=3; //正确
BOOL x=3.3; //告警
注：windows��Z��兼容问题定义的基��变量�?br />typedef unsigned long       DWORD;
typedef int                 BOOL;
typedef unsigned char       BYTE;
typedef unsigned short      WORD;
typedef float               FLOAT;
typedef FLOAT               *PFLOAT;
typedef BOOL near           *PBOOL;
typedef BOOL far            *LPBOOL;
typedef BYTE near           *PBYTE;
typedef BYTE far            *LPBYTE;
typedef int near            *PINT;
typedef int far             *LPINT; //   maximum   heap   size

);

旅�?/a> 2007-10-29 01:46 发表评论

++ �Q�？�Q�？�Q�？

Sun, 28 Oct 2007 17:42:00 GMT

int main()
{
   int i=0;
    printf("%d,%d,%d",(++i),(++i),(++i));
}
3 2 1

int main()
{
    int i=0;
    printf("%d,%d,%d",(i++),(i++),(i++));
}
0 0 0

旅�?/a> 2007-10-29 01:42 发表评论

Strcpy与memcpy两函数的�l�典实现

Sun, 28 Oct 2007 17:23:00 GMT

char *strcpy(char *des, const char *src){
       assert((des != NULL) && (src != NULL));
       char *add = des;
       while ((*des++ = *src++) != ‘\0�? ;
return des;
}

void  *memcpy(void *pvTo, const void *pvFrom, size_t size) {
       assert((pvTo != NULL) && (pvFrom != NULL));      // 使用断言
       byte *pbTo = (byte *) pvTo;         // 防止改变pvTo的地址
       byte *pbFrom = (byte *) pvFrom; // 防止改变pvFrom的地址
       while(size -- > 0 screen.width/2)this.style.width=screen.width/2;" border="0" />
              *pbTo ++ = *pbFrom ++ ;
       return pvTo;
}

旅�?/a> 2007-10-29 01:23 发表评论

sizeof

Sun, 28 Oct 2007 17:12:00 GMT

试题2�Q�以下�ؓWindows NT下的32位C++�E�序�Q�请计算sizeof的�?br />

void Func ( char str[100] )
{
　sizeof( str ) = ?
}

void *p = malloc( 100 );
sizeof ( p ) = ?

　　解答�Q?br />

sizeof( str ) = 4
sizeof ( p ) = 4

　　剖析�Q?br />
　　Func ( char str[100] )函数中数�l�名作�ؓ函数形参�Ӟ��在函��C��内，数组名失��M��本��n的内涵，仅仅只是一个指针；在失��d��内涵的同�Ӟ��它还失去了其帔R��Ҏ��，可以作自增、自减等操作�Q�可以被修改�?br />
　　数组名的本质如下�Q?br />
　　�Q?�Q�数�l�名指代一�U�数据结构，�q�种数据�l�构��是数组�Q?br />
　　例如�Q?br />

char str[10];
cout << sizeof(str) << endl;

　　输出�l�果�?0�Q�str指代数据�l�构char[10]�?br />
　　�Q?�Q�数�l�名可以转换为指向其指代实体的指针，而且是一个指针常量，不能作自增、自减等操作�Q�不能被修改�Q?br />

char str[10];
str++; //�~�译出错�Q�提�C�str不是左倹{��

　　�Q?�Q�数�l�名作�ؓ函数形参�Ӟ��沦�ؓ普通指针�?br />
　　Windows NT 32位��^��C��Q�指针的长度�Q�占用内存的大小�Q��ؓ4字节�Q�故sizeof( str ) 、sizeof ( p ) 都�ؓ4�?br />

旅�?/a> 2007-10-29 01:12 发表评论

分别�l�出BOOL�Q�int�Q�float�Q�指针变�?与“零值”比较的 if 语句

Sun, 28 Oct 2007 17:08:00 GMT

试题1�Q�分别给出BOOL�Q�int�Q�float�Q�指针变�?与“零值”比较的 if 语句�Q�假讑֏�量名为var�Q?br />
　　解答�Q?br />
　　　BOOL型变量：if(!var)

　　　int型变量： if(var==0)

　　　float型变量：

　　　const float EPSINON = 0.00001;

　　　if ((x >= - EPSINON) && (x <= EPSINON)

　　　指针变量�Q�　　if(var==NULL)

　　剖析�Q?br />
　　考查�?值判断的“内功”，BOOL型变量的0判断完全可以写成if(var==0)�Q�而int型变量也可以写成if(!var)�Q�指针变量的判断也可以写成if(!var)�Q�上�q�写法虽然程序都能正��运行，但是未能清晰地表辄��序的意思�?table align="left" border="0" cellpadding="0" cellspacing="0">

　　一般的�Q�如果想让if判断一个变量的“真”、“假”，应直接��用if(var)、if(!var)�Q�表明其为“逻辑”判断；如果用if判断一个数值型�? �?short、int、long�{?�Q�应该用if(var==0)�Q�表明是�?�q�行“数值”上的比较；而判断指针则适宜用if(var==NULL)�Q? �q�是一�U�很好的�~�程习惯�?br />
　　��点型变量�ƈ不精��，所以不可将float变量用�?=”或“！=”与数字比较�Q�应该设法�{化成�?gt;=”或�?lt;=”�Ş式。如果写成if (x == 0.0)�Q�则判�ؓ错，�?分�?img src ="http://www.shnenglu.com/mydriverc/aggbug/35390.html" width = "1" height = "1" />

旅�?/a> 2007-10-29 01:08 发表评论

GetMemory 攚w��

Sun, 28 Oct 2007 17:03:00 GMT

试题4�Q?br />

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

void Test( void )
{
　char *str = NULL;
　GetMemory( str );
　strcpy( str, "hello world" );
　printf( str );
}

　　试题5�Q?br />

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

void Test( void )
{
　char *str = NULL;
　str = GetMemory();
　printf( str );
}

　　试题6�Q?br />

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�Q?br />

void Test( void )
{
　char *str = (char *) malloc( 100 );
　strcpy( str, "hello" );
　free( str );
　... //省略的其它语�?br />}

　　解答�Q?br />
　　试题4传入中GetMemory( char *p )函数的�Ş参�ؓ字符串指针，在函数内部修改�Ş参�ƈ不能真正的改变传入�Ş参的��|��执行�?br />

char *str = NULL;
GetMemory( str );

　　后的str仍然为NULL�Q?br />
　　试题5�?br />

char p[] = "hello world";
return p;

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

*p = (char *) malloc( num );

　　后未判断内存是否甌��成功�Q�应加上�Q?br />

if ( *p == NULL )
{
　...//�q�行甌��内存��p�|处理
}

　　试题7存在与试�?同样的问题，在执�?br />

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

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

str = NULL;

　　试题6的Test函数中也未对malloc的内存进行释放�?br />
　　剖析�Q?br />
　　试题4�?考查面试者对内存操作的理解程度，基本功扎实的面试者一般都能正��的回答其中50~60的错误。但是要完全解答正确�Q�却也绝非易事�?br />
　　对内存操作的考查主要集中在：

　　�Q?�Q�指针的理解�Q?br />
　　�Q?�Q�变量的生存期及作用范围�Q?br />
　　�Q?�Q�良好的动态内存申请和释放习惯�?br />
　　再看看下面的一�D늨�序有什么错误：

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

　　在swap函数中，p是一个“野”指针，有可能指向系�l�区�Q�导致程序运行的崩溃。在VC++中DEBUG�q�行时提�C�错误“Access Violation”。该�E�序应该改�ؓ�Q?br />

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

旅�?/a> 2007-10-29 01:03 发表评论

strcpy

Sun, 28 Oct 2007 16:56:00 GMT

试题1�Q?br />

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

　　试题2�Q?br />

void test2()
{
　char string[10], str1[10];
　int i;
　for(i=0; i<10; i++)
　{
　　str1[i] = 'a';
　}
　strcpy( string, str1 );
}

　　试题3�Q?br />

void test3(char* str1)
{
　char string[10];
　if( strlen( str1 ) <= 10 )
　{
　　strcpy( string, str1 );
　}
}

　　解答�Q?br />
　　试题1字符串str1需�?1个字节才能存放下�Q�包括末��’\0’）�Q�而string只有10个字节的�I�间�Q�strcpy会导致数�l�越界；

　　对试�?�Q�如果面试者指出字�W�数�l�str1不能在数�l�内�l�束可以�l?分；如果面试者指出strcpy(string, str1)调用使得从str1内存起复制到string内存��h��复制的字节数��h��不确定性可以给7分，在此基础上指出库函数strcpy工作方式的给10 分；

　　对试�?�Q�if(strlen(str1) <= 10)应改为if(strlen(str1) < 10)�Q�因为strlen的结果未�l�计’\0’所占用�?个字节�?br />
　　剖析�Q?br />
　　考查对基本功的掌握：

　　(1)字符串以’\0’结��；

　　(2)�Ҏ��l�越界把握的敏感度；

　　(3)库函数strcpy的工作方式，如果�~�写一个标准strcpy函数的��d��gؓ10�Q�下面给出几个不同得分的�{�案�Q?br />
　　2�?br />

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

　　4�?br />

void strcpy( char *strDest, const char *strSrc )
//��源字符串加const�Q�表明其��入参敎ͼ��?�?br />{
　 while( (*strDest++ = * strSrc++) != ‘\0�?);
}

　　7�?br />

void strcpy(char *strDest, const char *strSrc)
{
　//�Ҏ��地址和目的地址加非0断言�Q�加3�?br />　assert( (strDest != NULL) && (strSrc != NULL) );
　while( (*strDest++ = * strSrc++) != ‘\0�?);
}

　　10�?br />

//��Z��实现铑ּ�操作�Q�将目的地址�q�回�Q�加3分！

char * strcpy( char *strDest, const char *strSrc )
{
　assert( (strDest != NULL) && (strSrc != NULL) );
　char *address = strDest;
　while( (*strDest++ = * strSrc++) != ‘\0�?);
　　return address;
}

　　�?分到10分的几个�{�案我们可以清楚的看刎ͼ��小的strcpy竟然暗藏着�q�么多玄机，真不是盖的！需要多么扎实的基本功才能写一个完��的strcpy啊！
(4)对strlen的掌握，它没有包括字�W�串末尾�?\0'�?br />
　读者看了不同分值的strcpy版本�Q�应该也可以写出一�?0分的strlen函数了，完美的版本�ؓ�Q?int strlen( const char *str ) //输入参数const

{
　assert( strt != NULL ); //断言字符串地址�?
　int len;
　while( (*str++) != '\0' )
　{
　　len++;
　}
　return len;
}

旅�?/a> 2007-10-29 00:56 发表评论

new �?malloc

Sun, 28 Oct 2007 16:50:00 GMT

malloc与free是C++/C语言的标准库函数�Q�new/delete是C++的运��符。它们都可用于申请动态内存和释放内存�?
对于非内部数据类型的对象而言�Q�光用maloc/free无法满��动态对象的要求。对象在创徏的同时要自动执行构造函敎ͼ�对象在消亡之前要自动执行析构�? 数。由于malloc/free是库函数而不是运��符�Q�不在编译器控制权限之内�Q�不能够把执行构造函数和析构函数的�Q务强加于malloc/free�?
因此C++语言需要一个能完成动态内存分配和初始化工作的�q�算�W�new�Q�以及一个能完成清理与释攑ֆ�存工作的�q�算�W�delete。注意new/delete不是库函数�?
我们先看一看malloc/free和new/delete如何实现对象的动态内存管理�?

class Obj
{
public :
Obj(void){ cout << “Initialization�? << endl; }
~Obj(void){ cout << “Destroy�? << endl; }
void Initialize(void){ cout << “Initialization�? << endl; }
void Destroy(void){ cout << “Destroy�? << endl; }
};
void UseMallocFree(void)
{
Obj *a = (obj *)malloc(sizeof(obj)); // 甌��动态内�?
a->Initialize(); // 初始�?
//�?
a->Destroy(); // 清除工作
free(a); // 释放内存
}
void UseNewDelete(void)
{
Obj *a = new Obj; // 甌��动态内存�ƈ且初始化
//�?
delete a; // 清除�q�且释放内存
}
用malloc/free和new/delete如何实现对象的动态内存管�?

�c�Obj的函数Initialize模拟了构造函数的功能�Q�函数Destroy模拟了析构函数的功能。函数UseMallocFree中，�׃�� malloc/free不能执行构造函��C��析构函数�Q�必��调用成员函数Initialize和Destroy来完成初始化与清除工作。函�? UseNewDelete则简单得多�?
所以我们不要企囄��malloc/free来完成动态对象的内存��理�Q�应该用new/delete。由于内部数据类型的“对象”没有构造与析构的过�E�，对它们而言malloc/free和new/delete是等��L��?
既然new/delete的功能完全覆盖了malloc/free�Q��ؓ什么C++不把malloc/free淘汰出局呢？�q�是因�ؓC++�E�序�l�常要调用C函数�Q�而C�E�序只能用malloc/free��理动态内存�?
如果用free释放“new创徏的动态对象”，那么该对象因无法执行析构函数而可能导致程序出错。如果用delete释放“malloc甌��的动态内存”，理论上讲�E�序不会出错�Q�但是该�E�序的可��L��很差。所以new/delete必须配对使用�Q�malloc/free也一栗�� ?

函数malloc的原型如下：
void * malloc(size_t size);
用malloc甌��一块长度�ؓlength的整数类型的内存�Q�程序如下：
int *p = (int *) malloc(sizeof(int) * length);
我们应当把注意力集中在两个要素上�Q�“类型�{换”和“sizeof”�?
malloc�q�回值的�c�d��是void *�Q�所以在调用malloc时要昑ּ�地进行类型�{换，��void * 转换成所需要的指针�c�d��。malloc函数本��n�q�不识别要申��L��内存是什么类型，它只兛_��内存的��d��节数。我们通常��C��住int, float�{�数据类型的变量的确切字节数�?

�q�算�W�new使用��h��要比函数malloc��单得多，例如�Q?
int *p1 = (int *)malloc(sizeof(int) * length);
int *p2 = new int[length];
�q�是因�ؓnew内置了sizeof、类型�{换和�c�d��安全��查功能。对于非内部数据�c�d��的对象而言�Q�new在创建动态对象的同时完成了初始化工作。如果对象有多个构造函敎ͼ�那么new的语句也可以有多�U��Ş式。例�?
class Obj
{
public :
Obj(void); // 无参数的构造函�?
Obj(int x); // 带一个参数的构造函�?
�?
}
void Test(void)
{
Obj *a = new Obj;
Obj *b = new Obj(1); // 初��gؓ1
�?
delete a;
delete b;
}
如果用new创徏对象数组�Q�那么只能��用对象的无参数构造函数�?/div>

区别两个

1 new是操作符
malloc是库函数

2 new可以调用构造函敎ͼ�malloc不可�?

�q�有�Q�这两个函数不存在内存分配大��问�?
�q�两个操作是在堆里面甌��内存�I�间�Q�除非空间不够了�Q�返回BULL指针�Q�否则都没有问题的，如果你出��C��某种情况�Q�看看是不是其它的问题。 �?
new 最�l�调用的是HeapAlloc,而HeapAlloc声明如下�Q?
LPVOID HeapAlloc(
HANDLE hHeap, // handle to the private heap block
DWORD dwFlags, // heap allocation control flags
DWORD dwBytes // number of bytes to allocate
);
其中�W�一个参数必��L��HeapCreate或GetProcessHeap 函数的返回句柄�?
如果是HeapCreate的话�Q�如下：�Q?
HANDLE HeapCreate(
DWORD flOptions, // heap allocation flag
DWORD dwInitialSize, // initial heap size
DWORD dwMaximumSize // maximum heap size
);
那么当该函数的最后一个参数非0�Ӟ��所创徏的堆要比0x7FFF8(512k)略小。如果�ؓ0�Q�则大小受到可用内存的限制�?
�q�有�Q�new甌��的内存不可移动，会造成内存��片�?/div>

内存分配最�l�都�?HEAP)上操�?允许的最大空间是_HEAP_MAXREQ=0xFFFFFFE0,但C�q�行库会在每�ơ额外分配一�? _CrtMemBlockHeader�l�构在该�ơ分配的内存起始�?同时在结束处多分配nNoMansLadnSize=4个字节的内存用于��检查调 �?因此通常的高效内存管理技术都是将多次��空间分配合�q�成一�ơ大�I�间分配,或只�q�行一�ơ分�?回收时不释放以直接用于下�ơ分配的 .
可分配空间�ƈ不等于一定可以分配到,�q�受环境的直接媄�?如页文�g的大��?�pȝ��已经占用的空间等.
当所�l�参数太�?会有�q�行时警�?Invalid allocation size: %u bytes.

旅�?/a> 2007-10-29 00:50 发表评论

Fri, 26 Oct 2007 17:04:00 GMT

�c�M��的常�?br /> 有时我们希望某些帔R��只在�c�M��有效。由�?define 定义的宏帔R��是全局的，不能
辑ֈ�目的�Q�于是想当然地觉得应该用const 修饰数据成员来实现。const 数据成员的确
是存在的�Q�但其含义却不是我们所期望的。const 数据成员只在某个对象生存期内是常
量，而对于整个类而言却是可变的，因�ؓ�c�d��以创建多个对象，不同的对象其const �?br /> 据成员的值可以不同�?br /> 不能在类声明中初始化const 数据成员。以下用法是错误的，因�ؓ�cȝ��对象未被�?br /> 建时�Q�编译器不知道SIZE 的值是什么�?br /> class A
{�?br /> const int SIZE = 100; // 错误�Q�企囑֜��c�d��明中初始化const 数据成员
int array[SIZE]; // 错误�Q�未知的SIZE
};
const 数据成员的初始化只能在类构造函数的初始化表中进行，例如
class A
{�?br /> A(int size); // 构造函�?br /> const int SIZE ;
};
A::A(int size) : SIZE(size) // 构造函数的初始化表
{
�?br /> }
A a(100); // 对象 a 的SIZE ��gؓ100
A b(200); // 对象 b 的SIZE ��gؓ200
怎样才能建立在整个类中都恒定的常量呢�Q�别指望const 数据成员了，应该用类�?br /> 的枚丑ָ�量来实现。例�?br /> class A
{�?br /> enum { SIZE1 = 100, SIZE2 = 200}; // 枚�D帔R��
int array1[SIZE1];
int array2[SIZE2];
};
枚�D帔R��不会占用对象的存储空��_��它们在编译时被全部求倹{��枚丑ָ�量的�~�点是：
它的隐含数据�c�d��是整敎ͼ�其最大值有限，且不能表�C��Q�Ҏ��Q�如PI=3.14159�Q��?br />

旅�?/a> 2007-10-27 01:04 发表评论

什么是堆内存分配栈内存分配

Fri, 26 Oct 2007 16:42:00 GMT

五大内存分区
在C++中，内存分成5个区�Q�他们分别是堆、栈、自由存储区、全局/静态存储区和常量存储区�?
栈，��是那些��q��译器在需要的时候分配，在不需要的时候自动清楚的变量的存储区。里面的变量通常是局部变量、函数参数等�?
堆，��是那些由new分配的内存块�Q�他们的释放�~�译器不�ȝ��Q�由我们的应用程序去控制�Q�一般一个new��p��对应一个delete。如果程序员没有释放掉，那么在程序结束后�Q�操作系�l�会自动回收�?
自由存储区，��是那些由malloc�{�分配的内存块，他和堆是十分�怼�的，不过它是用free来结束自��q��生命的�?
全局/静态存储区�Q�全局变量和静态变量被分配到同一块内存中�Q�在以前的C语言中，全局变量又分为初始化的和未初始化的，在C++里面没有�q�个区分了，他们共同占用同一块内存区�?
帔R��存储区，�q�是一块比较特�D�的存储区，他们里面存放的是帔R��Q�不允许修改�Q�当�Ӟ��你要通过非正当手�D�也可以修改�Q�而且�Ҏ��很多�Q�在《const的思考》一文中�Q�我�l�出�?�U�方法）

明确区分堆与�?
在bbs上，堆与栈的区分问题�Q�似乎是一个永恒的话题�Q�由此可见，初学者对此往往是�؜淆不清的�Q�所以我军_��拿他�W�一个开刀�?
首先�Q�我们�D一个例子：
void f() { int* p=new int[5]; }
�q�条短短的一句话��包含了堆与栈，看到new�Q�我们首先就应该惛_��Q�我们分配了一块堆内存�Q�那么指针p呢？他分配的是一块栈内存�Q�所以这句话的意思就是：在栈内存中存放了一个指向一块堆内存的指针p。在�E�序会先��定在堆中分配内存的大小�Q�然后调用operator new分配内存�Q�然后返回这块内存的首地址�Q�放入栈中，他在VC6下的汇编代码如下�Q?
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
�q�里�Q�我们�ؓ了简单�ƈ没有释放内存�Q�那么该怎么去释攑֑��Q�是delete p么？澻I��错了�Q�应该是delete []p�Q�这是�ؓ了告诉编译器�Q�我删除的是一个数�l�，VC6��׃��Ҏ��相应的Cookie信息去进行释攑ֆ�存的工作�?
好了�Q�我们回到我们的主题�Q�堆和栈�I�竟有什么区别？
主要的区别由以下几点�Q?
1、管理方式不同；
2、空间大��不同；
3、能否��生碎片不同；
4、生长方向不同；
5、分配方式不同；
6、分配效率不同；
��理方式�Q�对于栈来讲�Q�是��q��译器自动��理�Q�无需我们手工控制�Q�对于堆来说�Q�释攑ַ�作由�E�序员控�Ӟ��Ҏ��产生memory leak�?
�I�间大小�Q�一般来讲在32位系�l�下�Q�堆内存可以辑ֈ�4G的空��_��从这个角度来看堆内存几乎是没有什么限制的。但是对于栈来讲�Q�一般都是有一定的�I�间大小的，例如�Q�在VC6下面�Q�默认的栈空间大��是1M�Q�好像是�Q�记不清楚了�Q�。当�Ӟ��我们可以修改�Q?
打开工程�Q�依�ơ操作菜单如下：Project->Setting->Link�Q�在Category 中选中Output�Q�然后在Reserve中设定堆栈的最大值和commit�?
注意�Q�reserve最��gؓ4Byte�Q�commit是保留在虚拟内存的页文�g里面�Q�它讄��的较大会使栈开辟较大的��|��可能增加内存的开销和启动时间�?
��片问题�Q�对于堆来讲�Q�频�J�的new/delete势必会造成内存�I�间的不�q�箋�Q�从而造成大量的碎片，使程序效率降低。对于栈来讲�Q�则不会存在�q�个问题�Q? 因�ؓ栈是先进后出的队列，他们是如此的一一对应�Q�以至于永远都不可能有一个内存块从栈中间弹出�Q�在他弹��Z��前，在他上面的后�q�的栈内容已�l�被弹出�Q�详�l�的可以参考数据结构，�q�里我们��׃��再一一讨论了�?
生长方向�Q�对于堆来讲�Q�生长方向是向上的，也就是向着内存地址增加的方向；对于栈来�Ԍ��它的生长方向是向下的�Q�是向着内存地址减小的方向增�ѝ�?
分配方式�Q�堆都是动态分配的�Q�没有静态分配的堆。栈�?�U�分配方式：静态分配和动态分配。静态分配是�~�译器完成的�Q�比如局部变量的分配。动态分配由alloca函数�q�行分配�Q�但是栈的动态分配和堆是不同的，他的动态分配是��q��译器�q�行释放�Q�无需我们手工实现�?
分配效率�Q�栈是机器系�l�提供的数据�l�构�Q�计��机会在底层�Ҏ��提供支持�Q�分配专门的寄存器存放栈的地址�Q�压栈出栈都有专门的指��o执行�Q�这��决定了栈的效率�? 较高。堆则是C/C++函数库提供的�Q�它的机制是很复杂的�Q�例如�ؓ了分配一块内存，库函��C��按照一定的��法�Q�具体的��法可以参考数据结�?操作�pȝ��Q�在�? 内存中搜索可用的��_��大小的空��_��如果没有��_��大小的空��_��可能是由于内存碎片太多）�Q�就有可能调用系�l�功能去增加�E�序数据�D늚�内存�I�间�Q�这样就有机会分到��够大��的内存�Q�然后进行返回。显�Ӟ��堆的效率比栈要低得多�?
从这里我们可以看刎ͼ�堆和栈相比，�׃��大量new/delete的��用，�Ҏ��造成大量的内存碎片；�׃��没有专门的系�l�支持，效率很低�Q�由于可能引发用��h�? 和核心态的切换�Q�内存的甌��Q�代价变得更加昂��c��所以栈在程序中是应用最�q�泛的，��q��是函数的调用也利用栈��d��成，函数调用�q�程中的参数�Q�返回地址�Q? EBP和局部变量都采用栈的方式存放。所以，我们推荐大家��量用栈�Q�而不是用堆�?
虽然栈有如此众多的好处，但是�׃��和堆相比不是那么灉|��Q�有时候分配大量的内存�I�间�Q�还是用堆好一些�?
无论是堆�q�是栈，都要防止��界现象的发生（除非你是故意使其��界�Q�，因�ؓ��界的结果要么是�E�序崩溃�Q�要么是摧毁�E�序的堆、栈�l�构�Q��生以想不到的�l�果,��? ��是在你的程序运行过�E�中�Q�没有发生上面的问题�Q�你�q�是要小心，说不定什么时候就崩掉�Q�那时候debug可是相当困难的：�Q?
对了�Q�还有一件事�Q�如果有人把堆栈合�v来说�Q�那它的意思是栈，可不是堆�Q�呵呵，清楚了？

旅�?/a> 2007-10-27 00:42 发表评论

Fri, 26 Oct 2007 16:23:00 GMT

让我们看看C++ 的“函数内联”是如何工作的。对于�Q何内联函敎ͼ��~�译器在�W�号
表里攑օ�函数的声明（包括名字、参数类型、返回值类型）。如果编译器没有发现内联�?br />数存在错误，那么该函数的代码也被攑օ��W�号表里。在调用一个内联函数时�Q�编译器�?br />先检查调用是否正��（�q�行�c�d��安全��查，或者进行自动类型�{换，当然�Ҏ��有的函数
都一��P��。如果正��，内联函数的代码就会直接替换函数调用，于是省去了函数调用的开
销。这个过�E�与预处理有显著的不同，因�ؓ预处理器不能�q�行�c�d��安全��查，或者进�?br />自动�c�d��转换。假如内联函数是成员函数�Q�对象的地址�Q�this�Q�会被放在合适的地方�Q?br />�q�也是预处理器办不到的�?br />C++ 语言的函数内联机制既具备宏代码的效率�Q�又增加了安全性，而且可以自由�?br />作类的数据成员。所以在C++ �E�序中，应该用内联函数取代所有宏代码�Q�“断�a�assert�?br />恐怕是唯一的例外。assert 是仅在Debug 版本起作用的宏，它用于检查“不应该”发�?br />的情��c��ؓ了不在程序的Debug 版本和Release 版本引�v差别�Q�assert 不应该��生�Q何副
作用。如果assert 是函敎ͼ��׃��函数调用会引起内存、代码的变动�Q�那么将��D��Debug
版本与Release 版本存在差异。所以assert 不是函数�Q�而是宏�?img src ="http://www.shnenglu.com/mydriverc/aggbug/35279.html" width = "1" height = "1" />

旅�?/a> 2007-10-27 00:23 发表评论

/

Fri, 26 Oct 2007 09:47:00 GMT

#include
int main()
{
   int i=102/4*6;
   printf("%d\n",i);
   i=float(102/4)*6;
   printf("%d\n",i);
   i=float(102)/4*6;
   printf("%d\n",i);

   float a=102/4;
   float b=float(102)/4;
   printf("%f %f\n",a,b);
   return 1;
}
150
150
153
25.0000000
25.500000

旅�?/a> 2007-10-26 17:47 发表评论

Fri, 26 Oct 2007 09:30:00 GMT

C/C++ 里大多数�q�算�W�都可以�?C++ 中被重蝲。C 的运��符中只�?.�??:�Q�以�?sizeof�Q�技术上可以看作一个运��符�Q�不可以被重载。C++ 增加了一些自��q��q�算�W�，除了 :: �?.* �?/tt>�Q�大多数都可以被重蝲�?img src ="http://www.shnenglu.com/mydriverc/aggbug/35252.html" width = "1" height = "1" /> 旅�?/a> 2007-10-26 17:30 发表评论

scanf 详解 Sun, 21 Oct 2007 17:24:00 GMT # include ; int scanf( const char *format, ... ); 函数 scanf() 是从标准输入��?stdin 中读内容的通用子程序，可以��d��全部固有�c�d��的数据�ƈ自动转换成机内�Ş式。scanf() �?printf() 的补函数�?br /> �?C99 中，format �?restrict 修饰�?br /> format 指向的控制串�׃��下三�c�d��W�组成： �?格式说明�W?br /> �?�I�白�W?br /> �?非空白符输入格式说明�W�前�~�为百分号(%)�Q�告�?scanf() 下次��d��何种数据�c�d��。这些格式说明符的清单如下表所�C�： ┏━━━━┯━━━━━━━━━━━━━━━━━━━━━━━━━━━━�?br /> �?代码 │�? 意�? 义�? �?br /> ┠────┼────────────────────────────�?br /> ┃�? %a │读��点�?仅适用�?C99) �?br /> ┃�? %A │读��点�?仅适用�?C99) �?br /> ┃�? %c │读单字�W��? �?br /> ┃�? %d │读十进制整敊W? �?br /> ┃�? %i │读十进制、八�q�制、十六进制整敊W? �?br /> ┃�? %e │读��点敊W? �?br /> ┃�? %E │读��点敊W? �?br /> ┃�? %f │读��点敊W? �?br /> ┃�? %F │读��点�?仅适用�?C99) �?br /> ┃�? %g │读��点敊W? �?br /> ┃�? %G │读��点敊W? �?br /> ┃�? %o │读八进制数 �?br /> ┃�? %s │读字符串�? �?br /> ┃�? %x │读十六�q�制敊W? �?br /> ┃�? %X │读十六�q�制敊W? �?br /> ┃�? %p │读指针值�? �?br /> ┃�? %n │至此已��d��值的�{��h字符敊W? �?br /> ┃�? %u │读无符号十�q�制整数 �?br /> ┃ �?[ ] │扫描字�W�集合�? �?br /> ┃�? %% │读 % �W�号(癑ֈ��? �?br /> ┗━━━━┷━━━━━━━━━━━━━━━━━━━━━━━━━━━━�?br /> 例如�Q?%s 表示��M��?%d 表示��L��数。格式串的处理顺序�ؓ从左到右�Q�格式说明符逐一与变元表中的变元匚w��。�ؓ了读取长整数�Q�可以将 l(ell) 攑֜�格式说明�W�的前面�Q��ؓ了读取短整数�Q�可以将 h 攑֜�格式说明�W�的前面。这些修饰符可以�?d、i、o、u �?x 格式代码一起��用�?br /> 默认情况下，a、f、e �?g 告诉 scanf() �?float 分配数据�?如果��? l(ell) 攑֜��q�些修饰�W�的前面�Q�则 scanf() �?double 分配数据。��?L ��是告诉 scanf()�Q�接收数据的变量�? long double 型变量�?br /> 如果使用的现代编译器�E�序支持 1995 �q�增加的宽字�W�特性，则可以与 c 格式代码一��P��?l 修饰�W�说明类�?wchar_t 的宽字符指针�Q�也可以�?s 格式代码一��P��?l 修饰�W�说明宽字符串的指针。l 修饰�W�也可以用于修饰扫描集，以说明宽字符�?br /> 控制串中的空白符�?scanf() 在输入流中蟩�q�一个或多个�I�白行。空白符可以是空�?space)、制表符(tab)和新行符(newline)�?本质上，控制串中的空白符�?scanf() 在输入流中读�Q�但不保存结果，直到发现非空白字�W��ؓ止�?br /> 非空白符�?scanf() 在流中读一个匹配的字符�q�忽略之。例如，"%d,%d" �?scanf() 先读入一个整敎ͼ��d��中放弃逗号�Q�然后读另一个整数。如未发现匹配，scanf() �q�回�?br /> scanf() 中用于保存读入值的变元必须都是变量指针�Q�即相应变量的地址�?br /> 在输入流中，数据��必��ȝ��I�格、制表符和新行符分割。逗号和分��L��不是分隔�W�，比如以下代码�Q?br /> scanf( "%d %d", &r, &c ); ��接受输�?10 20�Q�但遇到 10,20 则失败�?br /> 癑ֈ��?%)与格式符之间的星�?*)表示��L��定类型的数据但不保存�?/b>因此�Q?br /> scanf( "%d %*c %d", &x, &y ); �?10/20 的读入操作中�Q?0 攑օ�变量 x�Q?0 攑օ� y�?br /> 格式命��o可以说明最大域宽�?在百分号(%)与格式码之间的整数用于限制从对应域读入的最大字�W�数。例如，希望�?address ��d��不多�?20 个字�W�时�Q�可以书写成如下形式�Q?br /> scanf( "%20s", address ); 如果输入��的内容多于 20 个字�W�，则下��?scanf() 从此�ơ停止处开始读入�?若达到最大域宽前已遇到空白符�Q�则对该域的�ȝ��卛_��止；此时�Q�scanf() 跛_��下一个域�?br /> 虽然�I�格、制表符和新行符都用做域分割�W�号�Q�但��d��字符操作中却按一般字�W�处理。例如，对输入流 "x y" 调用�Q?br /> scanf( "%c%c%c", &a, &b, &c ); �q�回后，x 在变�?a 中，�I�格在变�?b 中，y 在变�?c 中�?br /> 注意�Q�控制串中的其它字符�Q�包括空根{��制表符和新行符�Q�都用于从输入流中匹配�ƈ攑ּ�字符�Q�被匚w��的字�W�都攑ּ�。例如，�l�定输入��?"10t20"�Q�调用： scanf( "%dt%d", &x, &y ); ��把 10 �?20 分别攑ֈ� x �?y 中，t 被放弃，因�ؓ t 在控制串中�?br /> ANSI C 标准�?scanf() 增加了一�U�新�Ҏ��，�U�Cؓ扫描�?scanset)�?扫描集定义一个字�W�集合，可由 scanf() ��d��其中允许的字�W��ƈ赋给对应字符数组�?扫描集合�׃��Ҏ��括号中的一串字�W�定义，左方括号前必��ȝ��以百分号�?例如�Q�以下的扫描集�� scanf() ��d��字符 A、B �?C�Q?br /> %[ABC] 使用扫描集时�Q�scanf() �q�箋吃进集合中的字符�q�放入对应的字符数组�Q�直到发��C��在集合中的字�W��ؓ�?��x��描集仅读匚w��的字�W?。返回时�Q�数�l�中攄��?null �l�尾、由��d��字符�l�成的字�W�串�?br /> 用字�W?^ 可以说明补集。把 ^ 字符放�ؓ扫描集的�W�一字符�Ӟ��构成其它字符�l�成的命令的补集合，指示 scanf() 只接受未说明的其它字�W��?br /> 对于许多实现来说�Q�用�q�字�W�可以说明一个范围�?例如�Q�以下扫描集�?scanf() 接受字母 A �?Z�Q?br /> %[A-Z] 重要的是要注意扫描集是区分大��写的。因此，希望扫描大、小写字�W�时�Q�应该分别说明大、小写字母�?br /> scanf() �q�回�{�于成功赋值的域数的��|��但由于星号修饰符而读入未赋值的域不计算在内。给�W�一个域赋值前已出错时�Q�返�?EOF�?br /> C99 �?scanf() 增加了几个格式修饰符�Q�hh、ll、j、z �?t。hh 修饰�W�可用于 d、i、o、u、x、X �? n。它说明相应的变元是 signed �?unsigned char ��|��或用�?n �Ӟ�� 相应的变元是指向 long char 型变量的指针。ll 修饰�W�也可用�?d、i、o、u、x、X �?n。它说明相应的变元是 signed 或�?unsigned long long int 倹{�?br /> j 格式修饰�W�应用于 d、i、o、u、x、X �?n�Q�说明匹配的变元是类�?intmax_t �?uintmax_t。这些类型在 ; 中声明，�q�说明最大宽度的整数�?br /> z 格式修饰�W�应用于 d、i、o、u、x、X �?n�Q�说明匹配的变元是指�?size_t �c�d��对象的指针。该�c�d��?; 中声明，�q�说�?sizeof 的结构�?br /> t 格式修饰�W�应用于 d、i、o、u、x、X �?n�Q�说明匹配的变元是指�?ptrdiff_t �c�d��对象的指针。该�c�d��?; 中声明，�q�说明两个指针之间的差别�?br /> 例子�Q?br /> # include ; int main( void ) { char str[80], str2[80]; int i; /* read a string and a integer */ scanf( "%s%d", str, &i ); /* read up to 79 chars into str */ scanf( "%79s", str ); /* skip the integer between the two strings */ scanf( "%s%*d%s", str, str2 ); return 0; } 相关函数�Q?br />printf() �?fscanf()�?img src ="http://www.shnenglu.com/mydriverc/aggbug/34815.html" width = "1" height = "1" /> 旅�?/a> 2007-10-22 01:24 发表评论 scanf Sun, 21 Oct 2007 17:22:00 GMT scanf("%d,%d",&i,&j); printf("%d,%d",i,j); 如果输入 1 2回�R 则返�?�Q�随机数 scanf("%d,%d\n",&i,&j); printf("%d,%d",i,j); 最后按回�R�Q�直道随便输入个东西旅�?/a> 2007-10-22 01:22 发表评论 scanf �I�格 Sun, 21 Oct 2007 17:10:00 GMT �׃��scanf函数在接收数据时�Q�是通过�I�格来区分数据项�? 如果你： char c[20]; scanf("%s",c); 输入:this is a c program! 它接收到this后遇到空��|��认�ؓ对应%s的数据项已结束，后面的（包含�I�格�Q�不能输入�? 你想输入带空格的字符�Ԍ��只有使用gets(c); 但遗憄��是用gets()函数一�ơ只能输入一个字�W�串�?img src ="http://www.shnenglu.com/mydriverc/aggbug/34813.html" width = "1" height = "1" /> 旅�?/a> 2007-10-22 01:10 发表评论 Sun, 21 Oct 2007 17:09:00 GMT void GetMemory2(char **p, int num) { *p = (char *)malloc(sizeof(char) * num); } void Test2(void) { char *str = NULL; GetMemory2(&str, 100); // 注意参数�?&str�Q�而不是str strcpy(str, "hello"); cout<< str << endl; free(str); } char *GetMemory3(int num) { char *p = (char *)malloc(sizeof(char) * num); return p; } void Test3(void) { char *str = NULL; str = GetMemory3(100); strcpy(str, "hello"); cout<< str << endl; free(str); } 旅�?/a> 2007-10-22 01:09 发表评论 const char * Sun, 21 Oct 2007 17:06:00 GMT #include void foo(const char *p) { p="world"; } int main() { const char* q="Hello"; foo(q); printf("%s\n",q); q="world"; printf("%s\n",q); } Hello world 旅�?/a> 2007-10-22 01:06 发表评论联发�W�试一个数�l�的使用 Sun, 21 Oct 2007 16:45:00 GMT #include void foo(int b[][3]) { b++; b[1][1]=9; } int main() { int a[][3]={{1,2,3},{4,5,6},{7,8,9}}; foo(a); printf("%d,%d\n",a[1][2],a[2][1]); } 6�Q? 旅�?/a> 2007-10-22 00:45 发表评论 memmove Sun, 21 Oct 2007 16:37:00 GMT 贴个VC下的源码看看�Q?br />void * __cdecl memmove ( void * dst, const void * src, size_t count ) { void * ret = dst; if (dst <= src || (char *)dst >= ((char *)src + count)) { /* * Non-Overlapping Buffers * copy from lower addresses to higher addresses */ while (count--) { *(char *)dst = *(char *)src; dst = (char *)dst + 1; src = (char *)src + 1; } } else { /* * Overlapping Buffers * copy from higher addresses to lower addresses */ dst = (char *)dst + count - 1; src = (char *)src + count - 1; while (count--) { *(char *)dst = *(char *)src; dst = (char *)dst - 1; src = (char *)src - 1; } } return(ret); } void * memmove(void * dest,const void *src,size_t count) { char *tmp, *s; if (dest <= src) { tmp = (char *) dest; s = (char *) src; while (count--) *tmp++ = *s++; } else { tmp = (char *) dest + count; s = (char *) src + count; while (count--) *--tmp = *--s; } return dest; } 旅�?/a> 2007-10-22 00:37 发表评论 ++i不��生��时变量，i++产生临时变量 Sun, 21 Oct 2007 16:36:00 GMT ++i: {*this += 1; return *this} i++: {tmpobj = *this; ++(*this); return tmpobj;} 旅�?/a> 2007-10-22 00:36 发表评论 strcat Sun, 21 Oct 2007 16:34:00 GMT strcat的实�? char * strcat(char * dest, const char * src) { char *tmp = dest; while (*dest) dest++; while ((*dest++ = *src++) != '\0') ; return tmp; } strcat(char *dest, const *src),其中�Q�src是以'\0'�l�尾的字�W�串�Q�通过遍历src把它的每个字�W�放到dest字符串里面，当遍历src遇到'\0'时结束。��?strcat要防止src的长度大于dest的长度，不然数组��界�?br /> 以下为摘�?C:\Program Files\Microsoft Visual Studio\VC98\CRT\SRC\strcat.c�Q? char * __cdecl strcat ( char * dst, const char * src ) { char * cp = dst; while( *cp ) cp++; /* find end of dst */ while( *cp++ = *src++ ) ; /* Copy src to end of dst */ return( dst ); /* return dst */ } 旅�?/a> 2007-10-22 00:34 发表评论 Thu, 11 Oct 2007 18:08:00 GMT 问题�Q?br /> 字符�Ԍ��music<<��丽的草原我的家>>。该字符串的长度即str.length()为：17�Q�而目前需要存入数据库对应�? 字段长度为：16。所以必��d��字符串进行截取。而前16个字节中�Q�“原”字只有半个。这样存入数据库��对会出现“？”。所以必��d��断是否是半个汉字�Q�即�? 能存入“music<<��丽的草”�?br /> 分析�Q?br /> 汉字是双字节�~�码�Q�它��Z��能够与英文字�W�分开�Q�每个字节的最高位一定�ؓ1。如果是汉字�Q�那么这个字节就是小�?的。这个函数就是通过�q�一原理实现的。所以要通过getBytes()转化为byte型，再比较与零的大小�? getBytes()是把一个字�W�串转成一个byte数组�Q�因��机的数据都是基于字�W�的�Q�也��是说一个字�W�串实际上就是一个字�W�流�Q�因此可以�{为字�W�数�l��?br /> �E�序�Q?br /> public static String getStr(String src, int len) { if (src == null) return null; if (src.getBytes().length <= len) return src; byte[] s = src.getBytes(); int flag = 0; for(int i=0;i if(s[i] < 0) flag++; } if(flag%2!=0) len--; byte[] d = new byte[len]; System.arraycopy(s, 0, d, 0, len); return new String(d); } 旅�?/a> 2007-10-12 02:08 发表评论 ascii 字符整数 Thu, 11 Oct 2007 17:55:00 GMT int main() { char b='0'; printf("%d\n",b); printf("%c\n",b); int i=48; printf("%d\n",i); printf("%c\n",i); return 1; } 48 0 48 0 表现形式不同�?br /> 旅�?/a> 2007-10-12 01:55 发表评论 ��国标准信息交换标准�?(ASCII) Thu, 11 Oct 2007 17:49:00 GMT ��国标准信息交换代码( American Standard Code for Information Interchange, ASCII )是由��国国家标准学会(American National Standard Institute , ANSI )制定的，标准的单字节字符�~�码�Ҏ��Q�用于基于文本的数据。�v始于50�q�代后期�Q�在1967�q�定案。它最初是��国国家标准�Q�供不同计算机在�怺�通信时用作共同遵守的西文字符�~�码标准�Q�后被ISO及CCITT�{�国际组�l�采用�?br /> ASCII 码��用指定的 7 位或 8 位二�q�制数组合来表示 128 �?256 �U�可能的字符。标�?ASCII 码��?7 位二�q�制数来表示所有的大写和小写字母，数字 0 �?9、标点符��P��以及在美式英语中使用的特�D�控制字�W�。目前许多基�?a target="_blank" >x86的系�l�都支持使用扩展�Q�或“高”）ASCII。扩�?ASCII 码允许将每个字符的第 8 位用于确定附加的 128 个特�D�符号字�W��?a target="_blank" >外来�?/a>字母和图形符受��?br /> �?8�?�?0 �?13 分别转换为退根{��制表、换行和回�R字符。它们�ƈ没有特定的图形显�C�，但会依不同的应用�E�序�Q�而对文本昄��有不同的影响控制字符二进制�? 十进�?十六�q�制 �~�写解释 0000 0000 0 00 NUL �I�字�W?Null) 0000 0001 1 01 SOH 标题开�? 0000 0010 2 02 STX 正文开�? 0000 0011 3 03 ETX 正文�l�束 0000 0100 4 04 EOT 传输�l�束 0000 0101 5 05 ENQ ��h�� 0000 0110 6 06 ACK 收到通知 0000 0111 7 07 BEL 响铃 0000 1000 8 08 BS 退�? 0000 1001 9 09 HT 水��^制表�W? 0000 1010 10 0A LF 换行�? 0000 1011 11 0B VT 垂直制表�W? 0000 1100 12 0C FF 换页�? 0000 1101 13 0D CR 回�R�? 0000 1110 14 0E SO 不用切换 0000 1111 15 0F SI 启用切换 0001 0000 16 10 DLE 数据链�\转义 0001 0001 17 11 DC1 讑֤�控制1 0001 0010 18 12 DC2 讑֤�控制2 0001 0011 19 13 DC3 讑֤�控制3 0001 0100 20 14 DC4 讑֤�控制4 0001 0101 21 15 NAK 拒绝接收 0001 0110 22 16 SYN 同步�I�闲 0001 0111 23 17 ETB 传输块结�? 0001 1000 24 18 CAN 取消 0001 1001 25 19 EM 介质中断 0001 1010 26 1A SUB 替补 0001 1011 27 1B ESC 溢出 0001 1100 28 1C FS 文�g分割�W? 0001 1101 29 1D GS 分组�W? 0001 1110 30 1E RS 记录分离�W? 0001 1111 31 1F US 单元分隔�W? 0111 1111 127 7F DEL 删除可显�C�字�W?br /> 二进制�? 十进�?十六�q�制字符 0010 0000 32 20 �I�格 0010 0001 33 21 ! 0010 0010 34 22 " 0010 0011 35 23 # 0010 0100 36 24 $ 0010 0101 37 25 % 0010 0110 38 26 & 0010 0111 39 27 ' 0010 1000 40 28 ( 0010 1001 41 29 ) 0010 1010 42 2A * 0010 1011 43 2B + 0010 1100 44 2C , 0010 1101 45 2D - 0010 1110 46 2E . 0010 1111 47 2F / 0011 0000 48 30 0 0011 0001 49 31 1 0011 0010 50 32 2 0011 0011 51 33 3 0011 0100 52 34 4 0011 0101 53 35 5 0011 0110 54 36 6 0011 0111 55 37 7 0011 1000 56 38 8 0011 1001 57 39 9 0011 1010 58 3A : 0011 1011 59 3B ; 0011 1100 60 3C < 0011 1101 61 3D = 0011 1110 62 3E > 0011 1111 63 3F ? 0100 0000 64 40 @ 可显�C�字�W?br /> 二进制�? 十进�?十六�q�制字符 0100 0001 65 41 A 0100 0010 66 42 B 0100 0011 67 43 C 0100 0100 68 44 D 0100 0101 69 45 E 0100 0110 70 46 F 0100 0111 71 47 G 0100 1000 72 48 H 0100 1001 73 49 I 0100 1010 74 4A J 0100 1011 75 4B K 0100 1100 76 4C L 0100 1101 77 4D M 0100 1110 78 4E N 0100 1111 79 4F O 0101 0000 80 50 P 0101 0001 81 51 Q 0101 0010 82 52 R 0101 0011 83 53 S 0101 0100 84 54 T 0101 0101 85 55 U 0101 0110 86 56 V 0101 0111 87 57 W 0101 1000 88 58 X 0101 1001 89 59 Y 0101 1010 90 5A Z 0101 1011 91 5B [ 0101 1100 92 5C \ 0101 1101 93 5D ] 0101 1110 94 5E ^ 0101 1111 95 5F _ 0110 0000 96 60 ` 可显�C�字�W?br /> 二进制�? 十进�?十六�q�制字符 0110 0001 97 61 a 0110 0010 98 62 b 0110 0011 99 63 c 0110 0100 100 64 d 0110 0101 101 65 e 0110 0110 102 66 f 0110 0111 103 67 g 0110 1000 104 68 h 0110 1001 105 69 i 0110 1010 106 6A j 0110 1011 107 6B k 0110 1100 108 6C l 0110 1101 109 6D m 0110 1110 110 6E n 0110 1111 111 6F o 0111 0000 112 70 p 0111 0001 113 71 q 0111 0010 114 72 r 0111 0011 115 73 s 0111 0100 116 74 t 0111 0101 117 75 u 0111 0110 118 76 v 0111 0111 119 77 w 0111 1000 120 78 x 0111 1001 121 79 y 0111 1010 122 7A z 0111 1011 123 7B { 0111 1100 124 7C | 0111 1101 125 7D } 0111 1110 126 7E ~ 旅�?/a> 2007-10-12 01:49 发表评论

亚洲性久久久影院,国内精品伊人久久久久妇,国产综合久久久久

关于C++�c�d��const函数

const成员函数

头文�? extern

++ �Q�？�Q�？�Q�？

Strcpy与memcpy两函数的�l�典实现

sizeof

分别�l�出BOOL�Q�int�Q�float�Q�指针变�?与“零值”比较的 if 语句

GetMemory 攚w��

strcpy

new �?malloc

什么是堆内存分配栈内存分配

/

scanf 详解

scanf

scanf �I�格

const char *

联发�W�试 一个数�l�的使用

memmove

++i不��生��时变量，i++产生临时变量

strcat

ascii 字符 整数

���国标准信息交换标准�?(ASCII)

联发�W�试一个数�l�的使用

ascii 字符整数

��国标准信息交换标准�?(ASCII)