IT博客-textbox-随笔分类-c++/c

Recv与Send的超时

零度 — Sat, 14 Jul 2012 08:30:00 GMT

用setsockopt()来控制recv()与send()的超时

在send(),recv()过程中有时由于网络状况等原因，收发不能预期进行,而设置收发超时控制：
在Linux下需要注意的是时间的控制结构是struct timeval而并不是某一整型数，
int nNetTimeout=1000;//1秒，
//设置发送超时
setsockopt(socket，SOL_SOCKET,SO_SNDTIMEO，(char *)&nNetTimeout,sizeof(int));
//设置接收超时
setsockopt(socket，SOL_SOCKET,SO_RCVTIMEO，(char *)&nNetTimeout,sizeof(int));
这样做在Linux环境下是不会产生效果的，须如下定义：struct timeval timeout = {3,0};
//设置发送超时
setsockopt(socket，SOL_SOCKET,SO_SNDTIMEO，(char *)&timeout,sizeof(struct timeval));
//设置接收超时
setsockopt(socket，SOL_SOCKET,SO_RCVTIMEO，(char *)&timeout,sizeof(struct timeval));
有两点注意就是：
1）recv ()的第四个参数需为MSG_WAITALL，在阻塞模式下不等到指定数目的数据不会返回，除非超时时间到。还要注意的是只要设置了接收超时，在没有 MSG_WAITALL时也是有效的。说到底超时就是不让你的程序老在那儿等，到一定时间进行一次返回而已。
2）即使等待超时时间值未到，但对方已经关闭了socket，则此时recv()会立即返回，并收到多少数据返回多少数据。

零度 2012-07-14 16:30 发表评论

MFC類圖

零度 — Thu, 08 Jul 2010 03:59:00 GMT

零度 2010-07-08 11:59 发表评论

char 转wchar_t 及wchar_t转char (转)

零度 — Tue, 16 Mar 2010 06:18:00 GMT

char 转wchar_t 及wchar_t转char

原文来自 http://haofu123.blog.163.com/blog/static/178294920096243161997/

利用widechartomultibyte来转换的函数

通常适合于window平台上使用

#include <tchar.h>

#include <windows.h>

int _tmain(int argc, _tchar* argv[])

{

wchar_t pwstr[] =l"我是中国人";

wchar_t pwstr2[20];

    char *pcstr = (char *)malloc(sizeof(char)*(2 * wcslen(pwstr)+1));

    memset(pcstr , 0 , 2 * wcslen(pwstr)+1 );

    w2c(pcstr,pwstr,2 * wcslen(pwstr)+1) ;

    printf("%s\n",pcstr);

c2w(pwstr2,20,pcstr);

wprintf(l"%s",pwstr2);

    free(pcstr) ;

return 0;

}

//将wchar_t* 转成char*的实现函数如下：

char *w2c(char *pcstr,const wchar_t *pwstr, size_t len)

{

int nlength=wcslen(pwstr);

//获取转换后的长度

int nbytes = WideCharToMultiByte( 0, // specify the code page used to perform the conversion

0,         // no special flags to handle unmapped characters

pwstr,     // wide character string to convert

nlength,   // the number of wide characters in that string

NULL,      // no output buffer given, we just want to know how long it needs to be

0,

NULL,      // no replacement character given

NULL );    // we don't want to know if a character didn't make it through the translation

// make sure the buffer is big enough for this, making it larger if necessary

if(nbytes>len)   nbytes=len;

// 通过以上得到的结果，转换unicode 字符为ascii 字符

WideCharToMultiByte( 0, // specify the code page used to perform the conversion

0,         // no special flags to handle unmapped characters

pwstr,   // wide character string to convert

nlength,   // the number of wide characters in that string

pcstr, // put the output ascii characters at the end of the buffer

nbytes,                           // there is at least this much space there

NULL,      // no replacement character given

NULL );

return pcstr ;

}

//将char* 转成wchar_t*的实现函数如下：

//这是把asii字符转换为unicode字符，和上面相同的原理

void c2w(wchar_t *pwstr,size_t len,const char *str)

{

if(str)

    {

      size_t nu = strlen(str);

      size_t n =(size_t)multibytetowidechar(cp_acp,0,(const char *)str,(int)nu,null,0);

      if(n>=len)n=len-1;

      multibytetowidechar(cp_acp,0,(const char *)str,(int)nu,pwstr,(int)n);

   pwstr[n]=0;

    }

}

或者用此种方法更好一些：============我自已做的

//把ascii 字符转换为unicode字符

wchar_t* Cphone_hq::ctow(wchar_t *pwstr, const char *str)

{

wchar_t* buffer;

if(str)

    {

      size_t nu = strlen(str);

      size_t n =(size_t)MultiByteToWideChar(CP_ACP,0,(const char *)str,int(nu),NULL,0);

   buffer=0;

      buffer = new wchar_t[n+1];

      //if(n>=len) n=len-1;

   ::MultiByteToWideChar(CP_ACP,0,(const char *)str,int(nu),buffer,int(n));

   }

return buffer;

delete buffer;

}

typdef 函數指針 (轉）

零度 — Wed, 10 Mar 2010 03:23:00 GMT

函数指针
一个函数在编译时被分配一个入口地址，将这个入口地址称为函数的指针，可
以用一个指针变量指向该函数指针，然后通过该变量来调用函数。
有关说明：
　　1、函数指针的声明格式：
　　　函数返回值类型（＊指针变量名）（参数类型列表）
　　   或者是：
　　   typedef　函数返回值类型　（＊指针变量名）（参数类型列表）
    2、一个函数指针只能指向一种类型的函数，即具有相同的返回值和相同的参　　　　　　　　　　　　
　　　数的函数
　　３、关于函数指针的加减运算没有意义
　　函数指针数组定义：
     函数定义：
     void fun1(void *p);
     void fun2(void *p);
     void fun3(void *p);
　　函数指针数组定义：
　　 void(*fun[3])(void*);//typedef void(*pfun)(void*);pfun fun[3];
　　指针赋值：
     fun[0] = fun1;
     fun[1] = fun2;
     fun[2] = fun3;
     函数调用：
　　 fun[0](&a);         //int a;
     fun[1](&b);         //int b;
     fun[3](&c);         //int c;
声明一个指向成员函数的指针
一个指向成员函数的指针包括成员函数的返回类型，带::符号的类名称，函数参数表。虽然这一语法看似复杂，其实它和普通的指针是一样的。指向外部函数的指针可如下声明：
void (*pf)(char *, const char *);
void strcpy(char * dest, const char * source);
pf=strcpy;
相应指向类A的成员函数的指针如下表示：
void (A::*pmf)(char *, const char *);
以上pmf是指向类A的一个成员函数的指针，传递两个变量char *和 const char *，没有返回值。注意星号前面的A::符号，这和前面的声明是一致的。
赋值

为了给一个指向成员函数的指针赋值，可以采用成员函数名并再其前面加一个&的方式
使用typedef
你可以使用typedef来隐藏一些指向成员函数的复杂指针。例如，下面的代码定义了一个类A中的成员函数的指针PMA，并传递char *和const char *参数。
typedef void(A::*PMA)(char *, const char *);
PMA pmf= &A::strcat; // use a typedef to define a pointer to member
使用typedef特别有用，尤其是对于指向成员函数的数组指针。
■void类型的指针
   void含义：
   void是“无类型”，void*则为无类型指针，void*可以指向任何类型的数据。
   void a；//此变量没有任何实际意义，无法编译通过“illegal use of type”
   void 的作用：
       1、对程序返回的限定
       2、对函数参数的限定
   我们知道，如何指针p1和p2的类型相同，那么我们可以直接在p1和p2间赋值，如果不同，必须使用强制类型转换。
   如：float *p1;   int *p2;
   若：p1 = p2; 编译出错：“can not covert from int* to float*”
   必须为：p1 = (float*)p2;
               而void*不同，任何类型的指针都可以直接赋为它，不需要强制类型转换：
               如：void *p1;   int *p2;
                   可作：p1 =p2;
                   无类型可以包容有类型，有类型不能包容无类型：
                   必须为：p2 = (int*)p1;
               viod 和 void*使用规则总结：
   ●     如果函数没有返回值，那么应声明为void类型
   在C语言中，凡不加返回值类型限定的函数，就会被编译器作为返回整型值处理。但是许多程序员却误以为其为void类型. 林锐博士《高质量C/C++编程》中提到：“C++语言有很严格的类型安全检查，不允许上述情况（指函数不加类型声明）发生”。可是编译器并不一定这么认定，譬如在Visual C++6.0中上述add函数的编译无错也无警告且运行正确，所以不能寄希望于编译器会做严格的类型检查。
   因此，为了避免混乱，我们在编写C/C++程序时，对于任何函数都必须一个不漏地指定其类型。如果函数没有返回值，一定要声明为void类型。这既是程序良好可读性的需要，也是编程规范性的要求。另外，加上void类型声明后，也可以发挥代码的“自注释”作用。代码的“自注释”即代码能自己注释自己。
   ● 如果函数无参数，那么应声明其参数为void
   ● 小心使用void指针类型
   按照ANSI的标准，不能对void指针进行算法操作，即下列操作是不合法的：
   void *pvoid;
   pvoid ++;         //ansi错误
   pvoid += 1;        //ansi 错误
   ansi标准之所以这样认定，是因为它坚持，进行算法操作的指针必须是确定知道其指向数据类型的大小的。
   但GUN（GUN’s Not Unix）则不这么认为，它指定void*的算法操作与char*一致。因此在GUN编译器中上述语句是正确的。
   在实际的程序中，为了迎合ansi标准，并提高程序的可移植性，我们可以这样实现同样功能的代码：
   void *pvoid;
   (char*)pvoid++;
   (char*)pvoid += 1;
   ● 如果函数的参数可以是任意类型指针，那么应声明其参数为void *
   典型的如内存操作函数memcpy和memset的函数原型分别为：
   void* memcpy(void *dest, const void *src, size_t len);
   void* memset(void *buffer,int c, size_t num);
   这样，任何类型的指针都可以传入memcpy和memset中，这也真实地体现了内存操作函数的意义，因为它操作的对象仅仅是一片内存，而不论内存是什类型。
   ● void不能代表一个真实的变量
   void a; //错误
   function(void a); //错误
■this指针
   《深入浅出MFC》中解释：
   定义类CRect，定义两个对象rect1、rect2，各有自己的m_color成员变量，但 rect1.setcolor和rect2.setcolor却都是通往唯一的CRect::setcolor成员函数，那么 CRect::setcolor如何处理不同对象的m_color？答案是由一个隐藏参数，名为this指针。当你调用：
   rect1.setcolro(2);
   rect2.setcolor(3);
   时，编译器实际上为你做出来一下的代码：
   CRect::setcolor(2,(CRect*)&rect1);
   CRect::setcolor(3,(CRect*)&rect2);
   多出来的参数，就是所谓的this指针。
   class CRect
   {

   ……

   public:

   void setcolor(int color){m_color = color};

   };

   被编译后，其实为：
   class CRect
   {
   ……
   public:
   void setcolor(int color,(CRect*)this){this->m_color = color};
   };

零度 2010-03-10 11:23 发表评论

STL (Standard Template Library)标准模板库 C++

零度 — Mon, 08 Mar 2010 07:46:00 GMT

摘要: 以下资料均来自网络上的。标准模板库（Standard Template Library，STL）是惠普实验室开发的一系列软件的统称。它是由Alexander Stepanov、Meng Lee和David R Musser在惠普实验室工作时所开发出来的。现在虽说它主要出现在C++中，但在被引入C++之前该技术就已经存在了很长的一段时间。　　STL的代码从广义上讲分为三类：algor... 阅读全文

零度 2010-03-08 15:46 发表评论

c/c++ vc/bc new/malloc() free()/delete()

零度 — Mon, 08 Mar 2010 03:03:00 GMT

看到上面的关键字有什么感想啊。他们都有相同的功能，区别在那里呢？ (网络上找来的一些）

（1）new是操作符，同+、-、*、/有着相同的地位，它是保留字，不用头文件的支持，创建的是一个对象；建立的对象你可以把它当成一个普通的对象,用成员函数访问,不要直接访问它的地址空间；
使用形式：
          new返回的是指针(指向new出来的那个对象)。
          失败返回异常

（2）malloc是个分配内存的函数，需要头文件的支持，分配的是一块内存区域,就用指针访问好了,而且还可以在里面移动指针。
       使用形式：
          （指针类型）malloc(sizeof())
            失败返回NULL指针

（3）malloc与free是C++/C语言的标准库函数，new/delete是C++的运算符。它们都可用于申请动态内存和释放内存。
（4）对于非内部数据类型的对象而言，光用maloc/free无法满足动态对象的要求。对象在创建的同时要自动执行构造函数，对象在消亡之前要自动执行析构函数。由于malloc/free是库函数而不是运算符，不在编译器控制权限之内，不能够把执行构造函数和析构函数的任务强加于malloc/free.

（5）因此C++语言需要一个能完成动态内存分配和初始化工作的运算符new，以一个能完成清理与释放内存工作的运算符delete.注重new/delete不是库函数。
（6）C++程序经常要调用C函数，而C程序只能用malloc/free治理动态内存
          new 是个操作符，和什么"+"，"-"，"="……有一样的地位。
          malloc是个分配内存的函数，供你调用的。
          new是保留字，不需要头文件支持。
          malloc需要头文件库函数支持。
          new 建立的是一个对象，
          malloc分配的是一块内存。
          new建立的对象你可以把它当成一个普通的对象，用成员函数访问，不要直接访问它的地址空间
          malloc分配的是一块内存区域，就用指针访问好了，而且还可以在里面移动指针。
          简而言之：
          new 是一个操作符，可以重载
          malloc是一个函数，可以覆盖
          new 初始化对象，调用对象的构造函数，对应的delete调用相应的析构函数
          malloc仅仅分配内存，free仅仅回收内存。

相比 C 中的 malloc 和 free 函数， C++ 中的new 和delete的最大不同就是 delete释放内存时负责调用类的析构函数,new时会调用类的构造函数

对delete

class node

{

public:

};

对这个node类，

node *p=new node; 创建了一个新的对象，但是没有命名，是用指针指向这个对象，当使用

delete p;

时，就会释放这个指针所指向的空间，同时这个指针仍然指向这个空间的地址！

比如原来p指向0x78900789内存，delete p以后p依旧指向0x78900789，但这块地址已经没用了，如果再次被程序引用会出问题。所以必须要p=0
但这样写不是最好的，最好是写成p=NULL;

零度 2010-03-08 11:03 发表评论