C++博客-旅途-文章分类-C/C++

关于C++类内const函数

旅途 — Sun, 28 Oct 2007 18:52:00 GMT

据说有这种面试题：
class A
{
        public :
        char get_m() const
        {
                 return m;
        }
        private:
        char m;
}
请在函数get_m中改变m的值。

我想，对于这种流氓问题，只好使用流氓的做法：
        char get_m() const
        {
                char * p = (char *) &m;
                *p = 'C';
                 return m;
        }
呵呵，可以做到，因为类内const函数是通过“把类内成员都作为const”来实现的。
不过这是我这种“流氓程序员”的做法。

实际上，经过同事的教导，应该使用mutable修饰符：
mutable char m;
这样即使在类的const函数内，m的类型也是可以改变的了。

另外，如果想不要这份工作，也可以这么写：
#define const
哈哈，这样面试官就不敢要你啦。:D

旅途 2007-10-29 02:52 发表评论

const成员函数

旅途 — Sun, 28 Oct 2007 18:49:00 GMT

第五节　const成员函数

一些成员函数改变对象，一些成员函数不改变对象。

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


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

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


	例10-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 { 　 //... }

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

为什么需要const成员函数？
　　我们定义的类的成员函数中，常常有一些成员函数不改变类的数据成员，也就是说，这些函数是"只读"函数，而有一些函数要修改类数据成员的值。如果把不改变数据成员的函数都加上const关键字进行标识，显然，可提高程序的可读性。其实，它还能提高程序的可靠性，已定义成const的成员函数，一旦企图修改数据成员的值，则编译器按错误处理。
const成员函数和const对象
　　实际上，const成员函数还有另外一项作用，即常量对象相关。对于内置的数据类型，我们可以定义它们的常量，用户自定义的类也一样，可以定义它们的常量对象。例如，定义一个整型常量的方法为：
　　 const int i=1 ；
同样，也可以定义常量对象，假定有一个类classA，定义该类的常量对象的方法为：
　　 const classA a(2)；
　　这里，a是类classA的一个const对象，"2"传给它的构造函数参数。const对象的数据成员在对象寿命期内不能改变。但是，如何保证该类的数据成员不被改变呢？
　　为了确保const对象的数据成员不会被改变，在C++中，const对象只能调用const成员函数。如果一个成员函数实际上没有对数据成员作任何形式的修改，但是它没有被const关键字限定的，也不能被常量对象调用。下面通过一个例子来说明这个问题：


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

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

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

旅途 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

旅途 2007-10-29 02:41 发表评论

C++构造函数与析构函数执行顺序？？？

旅途 — Sun, 28 Oct 2007 18:31:00 GMT

今天在测试一个构造函数和析构函数的用例的时候，发现我们所钟爱的VC6.0实在是Bug问题越来越多，对于学习C++的新手来讲，有必要在这里给大家说明一下。

构造函数顺序为：

全局对象的构造函数；
main函数中对象的构造函数，包括automatic、static依次调用；
main中遇到函数中有局部对象时，进入到函数中调用局部对象的构造函数。

注：static对象的构造函数永远只调用一次。

析构函数顺序为：

退出函数时，执行函数内构造的automatic对象的析构函数，注：static对象不析构；
main函数中按构造的逆序析构automatic对象；
调用函数中定义的static对象的析构函数；
调用main中定义的static对象的析构函数；
最后调用全局对象的析构函数。

注：复合中的构造、析构顺序

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

析构：按对象构造的逆序析构。对于复合对象，先析构主对象，再析构其包含的对象。

比如有以下的测试用例：

//＃i nclude
＃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);

}

程序执行的时候，在VC6 withSp6下运行的结果

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 //在用的时候才有此句输出

其中包含有注释的部分，为调整包含的头文件为的情况下才有的输出。如果使用命名空间的std的话，没有最后的一句输出。

从百度上找了半天，才发现不是没有调用全局变量的析构函数，而是因为我们所用的编译器有问题，这是MS的产品对于C++的支持做的不是尽善尽美，有网友说在Vc7.0中好想消除了这个Bug。

旅途 2007-10-29 02:31 发表评论

头文件 extern

旅途 — Sun, 28 Oct 2007 18:02:00 GMT

　　试题4：为什么标准头文件都有类似以下的结构？

#ifndef __INCvxWorksh
#define __INCvxWorksh
#ifdef __cplusplus

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

#endif
#endif /* __INCvxWorksh */

　　解答：

　　头文件中的编译宏

#ifndef　__INCvxWorksh
#define　__INCvxWorksh
#endif

　　的作用是防止被重复引用。

　　作为一种面向对象的语言，C++支持函数重载，而过程式语言C则不支持。函数被C++编译后在symbol库中的名字与C语言的不同。例如，假设某个函数的原型为：

void foo(int x, int y);

　　该函数被C编译器编译后在symbol库中的名字为_foo，而C++编译器则会产生像_foo_int_int之类的名字。_foo_int_int这样的名字包含了函数名和函数参数数量及类型信息，C++就是考这种机制来实现函数重载的。

　　为了实现C和C++的混合编程，C++提供了C连接交换指定符号extern "C"来解决名字匹配问题，函数声明前加上extern "C"后，则编译器就会按照C语言的方式将该函数编译为_foo，这样C语言中就可以调用C++的函数了。

旅途 2007-10-29 02:02 发表评论

BOOL和bool的区别

旅途 — Sun, 28 Oct 2007 17:46:00 GMT

一：在网上找到了BOOL和bool的区别：
1、类型不同
BOOL为int型
bool为布尔型
2、长度不同
bool只有一个字节
BOOL长度视实际环境来定，一般可认为是4个字节
3、取值不同
bool取值false和true，是0和1的区别
BOOL取值FALSE和TRUE，是0和非0的区别
二：
bool是标准C++数据类型，可取值true和false。单独占一个字节，
如果数个bool对象列在一起，可能会各占一个bit，这取决于编译器。

BOOL是微软定义的typedef int BOOL。与bool不同，它是一个三值逻辑

，
TRUE/FALSE/ERROR，返回值为>0的整数为TRUE，0为FALSE，-1为ERROR。
Win32 API中很多返回值为BOOL的函数都是三值逻辑。比如GetMessage

().
三：
大BOOL和小bool之间的区别：
1、类型不同
BOOL为int型
bool为布尔型
2、长度不同
bool只有一个字节
BOOL长度视实际环境来定，一般可认为是4个字节
3、取值不同
bool取值false和true，是0和1的区别
BOOL取值FALSE和TRUE，是0和非0的区别
4、例子
bool x=3; //告警
bool x=1; //正确
BOOL x=3; //正确
BOOL x=3.3; //告警
注：windows为了兼容问题定义的基础变量。
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

);

旅途 2007-10-29 01:46 发表评论

++ ？？？？？？

旅途 — 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

旅途 2007-10-29 01:42 发表评论

Strcpy与memcpy两函数的经典实现

旅途 — 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;
}

旅途 2007-10-29 01:23 发表评论

sizeof

旅途 — Sun, 28 Oct 2007 17:12:00 GMT

试题2：以下为Windows NT下的32位C++程序，请计算sizeof的值

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

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

　　解答：

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

　　剖析：

　　Func ( char str[100] )函数中数组名作为函数形参时，在函数体内，数组名失去了本身的内涵，仅仅只是一个指针；在失去其内涵的同时，它还失去了其常量特性，可以作自增、自减等操作，可以被修改。

　　数组名的本质如下：

　　（1）数组名指代一种数据结构，这种数据结构就是数组；

　　例如：

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

　　输出结果为10，str指代数据结构char[10]。

　　（2）数组名可以转换为指向其指代实体的指针，而且是一个指针常量，不能作自增、自减等操作，不能被修改；

char str[10];
str++; //编译出错，提示str不是左值　

　　（3）数组名作为函数形参时，沦为普通指针。

　　Windows NT 32位平台下，指针的长度（占用内存的大小）为4字节，故sizeof( str ) 、sizeof ( p ) 都为4。

旅途 2007-10-29 01:12 发表评论

分别给出BOOL，int，float，指针变量与“零值”比较的 if 语句

旅途 — Sun, 28 Oct 2007 17:08:00 GMT

试题1：分别给出BOOL，int，float，指针变量与“零值”比较的 if 语句（假设变量名为var）

　　解答：

　　　BOOL型变量：if(!var)

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

　　　float型变量：

　　　const float EPSINON = 0.00001;

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

　　　指针变量：　　if(var==NULL)

　　剖析：

　　考查对0值判断的“内功”，BOOL型变量的0判断完全可以写成if(var==0)，而int型变量也可以写成if(!var)，指针变量的判断也可以写成if(!var)，上述写法虽然程序都能正确运行，但是未能清晰地表达程序的意思。

　　一般的，如果想让if判断一个变量的“真”、“假”，应直接使用if(var)、if(!var)，表明其为“逻辑”判断；如果用if判断一个数值型变量(short、int、long等)，应该用if(var==0)，表明是与0进行“数值”上的比较；而判断指针则适宜用if(var==NULL)，这是一种很好的编程习惯。

　　浮点型变量并不精确，所以不可将float变量用“==”或“！=”与数字比较，应该设法转化成“>=”或“<=”形式。如果写成if (x == 0.0)，则判为错，得0分。

旅途 2007-10-29 01:08 发表评论

GetMemory 改错

旅途 — Sun, 28 Oct 2007 17:03:00 GMT

试题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;
}

旅途 2007-10-29 01:03 发表评论

strcpy

旅途 — Sun, 28 Oct 2007 16:56:00 GMT

试题1：

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[i] = '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’结尾；

　　(2)对数组越界把握的敏感度；

　　(3)库函数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;
}

　　从2分到10分的几个答案我们可以清楚的看到，小小的strcpy竟然暗藏着这么多玄机，真不是盖的！需要多么扎实的基本功才能写一个完美的strcpy啊！
(4)对strlen的掌握，它没有包括字符串末尾的'\0'。

　读者看了不同分值的strcpy版本，应该也可以写出一个10分的strlen函数了，完美的版本为： int strlen( const char *str ) //输入参数const

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

旅途 2007-10-29 00:56 发表评论

new 和 malloc

旅途 — Sun, 28 Oct 2007 16:50:00 GMT

malloc与free是C++/C语言的标准库函数，new/delete是C++的运算符。它们都可用于申请动态内存和释放内存。
对于非内部数据类型的对象而言，光用maloc/free无法满足动态对象的要求。对象在创建的同时要自动执行构造函数，对象在消亡之前要自动执行析构函数。由于malloc/free是库函数而不是运算符，不在编译器控制权限之内，不能够把执行构造函数和析构函数的任务强加于malloc/free。
因此C++语言需要一个能完成动态内存分配和初始化工作的运算符new，以及一个能完成清理与释放内存工作的运算符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; // 清除并且释放内存
}
用malloc/free和new/delete如何实现对象的动态内存管理

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

函数malloc的原型如下：
void * malloc(size_t size);
用malloc申请一块长度为length的整数类型的内存，程序如下：
int *p = (int *) malloc(sizeof(int) * length);
我们应当把注意力集中在两个要素上：“类型转换”和“sizeof”。
malloc返回值的类型是void *，所以在调用malloc时要显式地进行类型转换，将void * 转换成所需要的指针类型。malloc函数本身并不识别要申请的内存是什么类型，它只关心内存的总字节数。我们通常记不住int, float等数据类型的变量的确切字节数。

运算符new使用起来要比函数malloc简单得多，例如：
int *p1 = (int *)malloc(sizeof(int) * length);
int *p2 = new int[length];
这是因为new内置了sizeof、类型转换和类型安全检查功能。对于非内部数据类型的对象而言，new在创建动态对象的同时完成了初始化工作。如果对象有多个构造函数，那么new的语句也可以有多种形式。例如
class Obj
{
public :
Obj(void); // 无参数的构造函数
Obj(int x); // 带一个参数的构造函数
…
}
void Test(void)
{
Obj *a = new Obj;
Obj *b = new Obj(1); // 初值为1
…
delete a;
delete b;
}
如果用new创建对象数组，那么只能使用对象的无参数构造函数。

区别两个

1 new是操作符
malloc是库函数

2 new可以调用构造函数，malloc不可以

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

内存分配最终都堆(HEAP)上操作,允许的最大空间是_HEAP_MAXREQ=0xFFFFFFE0,但C运行库会在每次额外分配一个 _CrtMemBlockHeader结构在该次分配的内存起始处,同时在结束处多分配nNoMansLadnSize=4个字节的内存用于检测检查调试.因此通常的高效内存管理技术都是将多次小空间分配合并成一次大空间分配,或只进行一次分配,回收时不释放以直接用于下次分配的 .
可分配空间并不等于一定可以分配到,这受环境的直接影响,如页文件的大小,系统已经占用的空间等.
当所给参数太大,会有运行时警告:Invalid allocation size: %u bytes.

旅途 2007-10-29 00:50 发表评论

类中的常量

旅途 — Fri, 26 Oct 2007 17:04:00 GMT

类中的常量
有时我们希望某些常量只在类中有效。由于#define 定义的宏常量是全局的，不能
达到目的，于是想当然地觉得应该用const 修饰数据成员来实现。const 数据成员的确
是存在的，但其含义却不是我们所期望的。const 数据成员只在某个对象生存期内是常
量，而对于整个类而言却是可变的，因为类可以创建多个对象，不同的对象其const 数
据成员的值可以不同。
不能在类声明中初始化const 数据成员。以下用法是错误的，因为类的对象未被创
建时，编译器不知道SIZE 的值是什么。
class A
{…
const int SIZE = 100; // 错误，企图在类声明中初始化const 数据成员
int array[SIZE]; // 错误，未知的SIZE
};
const 数据成员的初始化只能在类构造函数的初始化表中进行，例如
class A
{…
A(int size); // 构造函数
const int SIZE ;
};
A::A(int size) : SIZE(size) // 构造函数的初始化表
{
…
}
A a(100); // 对象 a 的SIZE 值为100
A b(200); // 对象 b 的SIZE 值为200
怎样才能建立在整个类中都恒定的常量呢？别指望const 数据成员了，应该用类中
的枚举常量来实现。例如
class A
{…
enum { SIZE1 = 100, SIZE2 = 200}; // 枚举常量
int array1[SIZE1];
int array2[SIZE2];
};
枚举常量不会占用对象的存储空间，它们在编译时被全部求值。枚举常量的缺点是：
它的隐含数据类型是整数，其最大值有限，且不能表示浮点数（如PI=3.14159）。

旅途 2007-10-27 01:04 发表评论

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

旅途 — Fri, 26 Oct 2007 16:42:00 GMT

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

明确区分堆与栈
在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势必会造成内存空间的不连续，从而造成大量的碎片，使程序效率降低。对于栈来讲，则不会存在这个问题，因为栈是先进后出的队列，他们是如此的一一对应，以至于永远都不可能有一个内存块从栈中间弹出，在他弹出之前，在他上面的后进的栈内容已经被弹出，详细的可以参考数据结构，这里我们就不再一一讨论了。
生长方向：对于堆来讲，生长方向是向上的，也就是向着内存地址增加的方向；对于栈来讲，它的生长方向是向下的，是向着内存地址减小的方向增长。
分配方式：堆都是动态分配的，没有静态分配的堆。栈有2种分配方式：静态分配和动态分配。静态分配是编译器完成的，比如局部变量的分配。动态分配由alloca函数进行分配，但是栈的动态分配和堆是不同的，他的动态分配是由编译器进行释放，无需我们手工实现。
分配效率：栈是机器系统提供的数据结构，计算机会在底层对栈提供支持：分配专门的寄存器存放栈的地址，压栈出栈都有专门的指令执行，这就决定了栈的效率比较高。堆则是C/C++函数库提供的，它的机制是很复杂的，例如为了分配一块内存，库函数会按照一定的算法（具体的算法可以参考数据结构/操作系统）在堆内存中搜索可用的足够大小的空间，如果没有足够大小的空间（可能是由于内存碎片太多），就有可能调用系统功能去增加程序数据段的内存空间，这样就有机会分到足够大小的内存，然后进行返回。显然，堆的效率比栈要低得多。
从这里我们可以看到，堆和栈相比，由于大量new/delete的使用，容易造成大量的内存碎片；由于没有专门的系统支持，效率很低；由于可能引发用户态和核心态的切换，内存的申请，代价变得更加昂贵。所以栈在程序中是应用最广泛的，就算是函数的调用也利用栈去完成，函数调用过程中的参数，返回地址， EBP和局部变量都采用栈的方式存放。所以，我们推荐大家尽量用栈，而不是用堆。
虽然栈有如此众多的好处，但是由于和堆相比不是那么灵活，有时候分配大量的内存空间，还是用堆好一些。
无论是堆还是栈，都要防止越界现象的发生（除非你是故意使其越界），因为越界的结果要么是程序崩溃，要么是摧毁程序的堆、栈结构，产生以想不到的结果,就算是在你的程序运行过程中，没有发生上面的问题，你还是要小心，说不定什么时候就崩掉，那时候debug可是相当困难的：）
对了，还有一件事，如果有人把堆栈合起来说，那它的意思是栈，可不是堆，呵呵，清楚了？

旅途 2007-10-27 00:42 发表评论

C++ 的“函数内联”

旅途 — Fri, 26 Oct 2007 16:23:00 GMT

让我们看看C++ 的“函数内联”是如何工作的。对于任何内联函数，编译器在符号
表里放入函数的声明（包括名字、参数类型、返回值类型）。如果编译器没有发现内联函
数存在错误，那么该函数的代码也被放入符号表里。在调用一个内联函数时，编译器首
先检查调用是否正确（进行类型安全检查，或者进行自动类型转换，当然对所有的函数
都一样）。如果正确，内联函数的代码就会直接替换函数调用，于是省去了函数调用的开
销。这个过程与预处理有显著的不同，因为预处理器不能进行类型安全检查，或者进行
自动类型转换。假如内联函数是成员函数，对象的地址（this）会被放在合适的地方，
这也是预处理器办不到的。
C++ 语言的函数内联机制既具备宏代码的效率，又增加了安全性，而且可以自由操
作类的数据成员。所以在C++ 程序中，应该用内联函数取代所有宏代码，“断言assert”
恐怕是唯一的例外。assert 是仅在Debug 版本起作用的宏，它用于检查“不应该”发生
的情况。为了不在程序的Debug 版本和Release 版本引起差别，assert 不应该产生任何副
作用。如果assert 是函数，由于函数调用会引起内存、代码的变动，那么将导致Debug
版本与Release 版本存在差异。所以assert 不是函数，而是宏。

旅途 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

旅途 2007-10-26 17:47 发表评论

C++ 中不能重载的运算符

旅途 — Fri, 26 Oct 2007 09:30:00 GMT

C/C++ 里大多数运算符都可以在 C++ 中被重载。C 的运算符中只有 .和 ?:（以及 sizeof，技术上可以看作一个运算符）不可以被重载。C++ 增加了一些自己的运算符，除了 :: 和 .* 外，大多数都可以被重载。

旅途 2007-10-26 17:30 发表评论

scanf 详解

旅途 — Sun, 21 Oct 2007 17:24:00 GMT

# include ;
int scanf( const char *format, ... );

函数 scanf() 是从标准输入流 stdin 中读内容的通用子程序，可以读入全部固有类型的数据并自动转换成机内形式。scanf() 是 printf() 的补函数。

在 C99 中，format 用 restrict 修饰。

format 指向的控制串由以下三类字符组成：
   ● 格式说明符
   ● 空白符
   ● 非空白符
输入格式说明符前缀为百分号(%)，告诉 scanf() 下次读入何种数据类型。这些格式说明符的清单如下表所示：
┏━━━━┯━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
┃ 代  码 │          意                         义          ┃
┠────┼────────────────────────────┨
┃ %a │读浮点值(仅适用于 C99)                               ┃
┃ %A │读浮点值(仅适用于 C99)                               ┃
┃ %c │读单字符                                              ┃
┃ %d │读十进制整数                                           ┃
┃ %i │读十进制、八进制、十六进制整数                         ┃
┃ %e │读浮点数                                              ┃
┃ %E │读浮点数                                              ┃
┃ %f │读浮点数                                              ┃
┃ %F │读浮点数(仅适用于 C99)                               ┃
┃ %g │读浮点数                                              ┃
┃ %G │读浮点数                                              ┃
┃ %o │读八进制数                                           ┃
┃ %s │读字符串                                              ┃
┃ %x │读十六进制数                                           ┃
┃ %X │读十六进制数                                           ┃
┃ %p │读指针值                                              ┃
┃ %n │至此已读入值的等价字符数                               ┃
┃ %u │读无符号十进制整数                                     ┃
┃  %[ ]  │扫描字符集合                                           ┃
┃ %% │读 % 符号(百分号)                                     ┃
┗━━━━┷━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
例如： %s 表示读串而 %d 表示读整数。格式串的处理顺序为从左到右，格式说明符逐一与变元表中的变元匹配。为了读取长整数，可以将 l(ell) 放在格式说明符的前面；为了读取短整数，可以将 h 放在格式说明符的前面。这些修饰符可以与 d、i、o、u 和 x 格式代码一起使用。

默认情况下，a、f、e 和 g 告诉 scanf() 为 float 分配数据。如果将 l(ell) 放在这些修饰符的前面，则 scanf() 为 double 分配数据。使用 L 就是告诉 scanf()，接收数据的变量是 long double 型变量。

如果使用的现代编译器程序支持 1995 年增加的宽字符特性，则可以与 c 格式代码一起，用 l 修饰符说明类型 wchar_t 的宽字符指针；也可以与 s 格式代码一起，用 l 修饰符说明宽字符串的指针。l 修饰符也可以用于修饰扫描集，以说明宽字符。

控制串中的空白符使 scanf() 在输入流中跳过一个或多个空白行。空白符可以是空格(space)、制表符(tab)和新行符(newline)。本质上，控制串中的空白符使 scanf() 在输入流中读，但不保存结果，直到发现非空白字符为止。

非空白符使 scanf() 在流中读一个匹配的字符并忽略之。例如，"%d,%d" 使 scanf() 先读入一个整数，读入中放弃逗号，然后读另一个整数。如未发现匹配，scanf() 返回。

scanf() 中用于保存读入值的变元必须都是变量指针，即相应变量的地址。

在输入流中，数据项必须由空格、制表符和新行符分割。逗号和分号等不是分隔符，比如以下代码：
scanf( "%d %d", &r, &c );
将接受输入 10 20，但遇到 10,20 则失败。

百分号(%)与格式符之间的星号(*)表示读指定类型的数据但不保存。因此，
scanf( "%d %*c %d", &x, &y );
对 10/20 的读入操作中，10 放入变量 x，20 放入 y。

格式命令可以说明最大域宽。在百分号(%)与格式码之间的整数用于限制从对应域读入的最大字符数。例如，希望向 address 读入不多于 20 个字符时，可以书写成如下形式：
scanf( "%20s", address );

如果输入流的内容多于 20 个字符，则下次 scanf() 从此次停止处开始读入。若达到最大域宽前已遇到空白符，则对该域的读立即停止；此时，scanf() 跳到下一个域。

虽然空格、制表符和新行符都用做域分割符号，但读单字符操作中却按一般字符处理。例如，对输入流 "x y" 调用：
scanf( "%c%c%c", &a, &b, &c );
返回后，x 在变量 a 中，空格在变量 b 中，y 在变量 c 中。

注意，控制串中的其它字符，包括空格、制表符和新行符，都用于从输入流中匹配并放弃字符，被匹配的字符都放弃。例如，给定输入流 "10t20"，调用：
scanf( "%dt%d", &x, &y );
将把 10 和 20 分别放到 x 和 y 中，t 被放弃，因为 t 在控制串中。

ANSI C 标准向 scanf() 增加了一种新特性，称为扫描集(scanset)。扫描集定义一个字符集合，可由 scanf() 读入其中允许的字符并赋给对应字符数组。扫描集合由一对方括号中的一串字符定义，左方括号前必须缀以百分号。例如，以下的扫描集使 scanf() 读入字符 A、B 和 C：
%[ABC]

使用扫描集时，scanf() 连续吃进集合中的字符并放入对应的字符数组，直到发现不在集合中的字符为止(即扫描集仅读匹配的字符)。返回时，数组中放置以 null 结尾、由读入字符组成的字符串。

用字符 ^ 可以说明补集。把 ^ 字符放为扫描集的第一字符时，构成其它字符组成的命令的补集合，指示 scanf() 只接受未说明的其它字符。
对于许多实现来说，用连字符可以说明一个范围。例如，以下扫描集使 scanf() 接受字母 A 到 Z：
%[A-Z]
重要的是要注意扫描集是区分大小写的。因此，希望扫描大、小写字符时，应该分别说明大、小写字母。
scanf() 返回等于成功赋值的域数的值，但由于星号修饰符而读入未赋值的域不计算在内。给第一个域赋值前已出错时，返回 EOF。

C99 为 scanf() 增加了几个格式修饰符：hh、ll、j、z 和 t。hh 修饰符可用于 d、i、o、u、x、X 或 n。它说明相应的变元是 signed 或 unsigned char 值，或用于 n 时，相应的变元是指向 long char 型变量的指针。ll 修饰符也可用于 d、i、o、u、x、X 或 n。它说明相应的变元是 signed 或者 unsigned long long int 值。
j 格式修饰符应用于 d、i、o、u、x、X 或 n，说明匹配的变元是类型 intmax_t 或 uintmax_t。这些类型在 ; 中声明，并说明最大宽度的整数。
z 格式修饰符应用于 d、i、o、u、x、X 或 n，说明匹配的变元是指向 size_t 类型对象的指针。该类型在 ; 中声明，并说明 sizeof 的结构。
t 格式修饰符应用于 d、i、o、u、x、X 或 n，说明匹配的变元是指向 ptrdiff_t  类型对象的指针。该类型在 ; 中声明，并说明两个指针之间的差别。

例子：

# 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;
}

相关函数：
printf() 及 fscanf()。

旅途 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回车
则返回1，随机数

   scanf("%d,%d\n",&i,&j);
   printf("%d,%d",i,j);
最后按回车，直道随便输入个东西

旅途 2007-10-22 01:22 发表评论

scanf 空格

旅途 — Sun, 21 Oct 2007 17:10:00 GMT

由于scanf函数在接收数据时，是通过空格来区分数据项的.
如果你：
char c[20];
scanf("%s",c);
输入:this is a c program!
它接收到this后遇到空格，认为对应%s的数据项已结束，后面的（包含空格）不能输入。
你想输入带空格的字符串，只有使用gets(c);
但遗憾的是用gets()函数一次只能输入一个字符串。

旅途 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，而不是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);
}

旅途 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

旅途 2007-10-22 01:06 发表评论

联发笔试一个数组的使用

旅途 — 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，9

旅途 2007-10-22 00:45 发表评论

memmove

旅途 — Sun, 21 Oct 2007 16:37:00 GMT

贴个VC下的源码看看：
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;
}

旅途 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;}

旅途 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),其中，src是以'\0'结尾的字符串，通过遍历src把它的每个字符放到dest字符串里面，当遍历src遇到'\0'时结束。使用 strcat要防止src的长度大于dest的长度，不然数组越界。

以下为摘自:C:\Program   Files\Microsoft   Visual   Studio\VC98\CRT\SRC\strcat.c：

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   */

}

旅途 2007-10-22 00:34 发表评论

含有中文字符串的截取问题！

旅途 — Thu, 11 Oct 2007 18:08:00 GMT

问题：
    字符串：music<<美丽的草原我的家>>。该字符串的长度即str.length()为：17，而目前需要存入数据库对应的字段长度为：16。所以必须对字符串进行截取。而前16个字节中，“原”字只有半个。这样存入数据库确对会出现“？”。所以必须判断是否是半个汉字，即只能存入“music<<美丽的草”。

分析：
    汉字是双字节编码，它为了能够与英文字符分开，每个字节的最高位一定为1。如果是汉字，那么这个字节就是小于0的。这个函数就是通过这一原理实现的。所以要通过getBytes()转化为byte型，再比较与零的大小。
getBytes()是把一个字符串转成一个byte数组，因为计算机的数据都是基于字符的，也就是说一个字符串实际上就是一个字符流，因此可以转为字符数组。

程序：
    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);
}

旅途 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

表现形式不同。

旅途 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 )制定的，标准的单字节字符编码方案，用于基于文本的数据。起始于50年代后期，在1967年定案。它最初是美国国家标准，供不同计算机在相互通信时用作共同遵守的西文字符编码标准，后被ISO及CCITT等国际组织采用。

   ASCII 码使用指定的 7 位或 8 位二进制数组合来表示 128 或 256 种可能的字符。标准 ASCII 码使用 7 位二进制数来表示所有的大写和小写字母，数字 0 到 9、标点符号，以及在美式英语中使用的特殊控制字符。目前许多基于x86的系统都支持使用扩展（或“高”）ASCII。扩展 ASCII 码允许将每个字符的第 8 位用于确定附加的 128 个特殊符号字符、外来语字母和图形符号。

   值 8、9、10 和 13 分别转换为退格、制表、换行和回车字符。它们并没有特定的图形显示，但会依不同的应用程序，而对文本显示有不同的影响

控制字符
二进制       十进制十六进制缩写解释
0000 0000 0       00          NUL 空字符(Null)
0000 0001 1       01          SOH 标题开始
0000 0010 2       02          STX 正文开始
0000 0011 3       03          ETX 正文结束
0000 0100 4       04          EOT 传输结束
0000 0101 5       05          ENQ 请求
0000 0110 6       06          ACK 收到通知
0000 0111 7       07          BEL 响铃
0000 1000 8       08          BS    退格
0000 1001 9       09          HT    水平制表符
0000 1010 10       0A          LF    换行键
0000 1011 11       0B          VT    垂直制表符
0000 1100 12       0C          FF    换页键
0000 1101 13       0D          CR    回车键
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 同步空闲
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    文件分割符
0001 1101 29       1D          GS    分组符
0001 1110 30       1E          RS    记录分离符
0001 1111 31       1F          US    单元分隔符
0111 1111 127    7F          DEL    删除

可显示字符
二进制       十进制十六进制字符
0010 0000 32       20          空格
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          @

可显示字符
二进制       十进制十六进制字符
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          `

可显示字符
二进制       十进制十六进制字符
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          ~

旅途 2007-10-12 01:49 发表评论