C++博客-xyjzsh-随笔分类-数据结构

一种类型的字符拷贝函数

呆人 — Wed, 10 Aug 2011 06:02:00 GMT

1.函数原型：
LPTSTR lstrcpyn(

    LPTSTR lpString1,
    LPCTSTR lpString2,//指向一个以NULL结束的字符串
    int iMaxLength   //从lpString2拷贝到lpString1的字符串个数，包括NULL字符
);
成功返回指向lpString1的指针，否则返回NULL。

如果lpString2的长度大于iMaxLength，该方法实际上是将lpString2中的前iMaxLength-1个字符和一个NULL字符拷贝到lpString1中。
如果该方法成功，则lpString1一定是以NULL结束的字符串。

2._tcsncpy是一个宏，考虑在unicode的情况下
define _tcsncpy wcsncpy

wchar_t *wcsncpy(
   wchar_t *strDest,
   const wchar_t *strSource,
   size_t count
);

Parameters

strDest: Destination string.
strSource: Source string.
count: Number of characters to be copied.

Return Value

Returns strDest. No return value is reserved to indicate an error.
不能保证NULL结束，将count个字符拷贝到strDest中。

呆人 2011-08-10 14:02 发表评论

猜猜执行结果

呆人 — Wed, 20 Jul 2011 05:52:00 GMT

static const char *msg[] = {"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"};
char *get_a_day(int idx)
{
static char buf[20];
strcpy(buf, msg[idx]);
return buf;
}

int main()
{
char *day0 = get_a_day(0);
char *day1 = get_a_day(1);
printf("%s %s\n", day0, day1);
return 0;
}

结果是什么？

呆人 2011-07-20 13:52 发表评论

返回值为函数指针的写法

呆人 — Tue, 26 Apr 2011 07:36:00 GMT

下面方法的作用是：通过key的类型返回对应的哈希函数的指针

static int (*hashFunction(int keyClass))(const void*,int)
{
/*内容省略*/
}

函数的名字是：hashFunction,该函数为只有1个int型参数为。
该函数的返回值为一个函数指针，函数有2个参数，第一个类型为const void*,第二个为int，返回值为int 。

呆人 2011-04-26 15:36 发表评论

c语言中模拟动态绑定

呆人 — Tue, 26 Apr 2011 07:30:00 GMT

struct本身不能支持动态绑定，为了实现统一接口，我们希望实现动态绑定。
例如在不同的操作系统下，对文件的操作是不同，但是我们希望统一结构，有如下结构
struct OSFile
{
    PIOMethod pMethods;
   /*
   其他信息
*/
};

struct WinOSFile
{
PIOMethod pMethods;
..........
};

struct UnixOSFile
{
PIOMethod pMethods;
..........
};

有如下方法：
void UniAPI(OSFile *file);
为了实现动态绑定，做法是在调用该方法之前，将WinOSFile或者UnixOSFile的pMethods赋给OSFile的pMethods从而实现动态绑定。

呆人 2011-04-26 15:30 发表评论

按位使用数据以及union

呆人 — Tue, 15 Mar 2011 09:34:00 GMT

例如：
typedef union tagData
{
   long x:2;
   long y:4;
   long data;
}data_item,*pdata_item;

上述是一个联合体，联合体的对象用的空间是类型中占用内存最大的哪个，例如上例中data_item变量占用4个字节。
long x:2;
表示x占用2bit
long y:4;
表示y占用4bit
long data;
data占用4byte
所以上述union占用4byte空间。
long s=sizeof(data_item);
s=4;

因为x,y,data公用内存空间。
从低位开始，即
x占用空间的低2bit，即0-1
y占用空间2~5bit
x,y都是可以是有符号的，相对最高位表示符号位。
例如，
item_data t={0};
(1) t.data = 2;
2表示成二进制位10.
所以t.x 的值为-2;
(2) t.data = 3;
3表示成二进制位11
所以t.x的值为-1
(3) t.data =1;
此时t.x的值为1

t.y的取值的道理同t.x;
对于t.y来说第5位表示正负号。

呆人 2011-03-15 17:34 发表评论

宏定义中字符串连接操作

呆人 — Tue, 15 Mar 2011 05:49:00 GMT

宏定义中字符串连接操作

关于记号粘贴操作符(token paste operator): ##

1. 简单的说，“##”是一种分隔连接方式，它的作用是先分隔，然后进行强制连接。

   其中，分隔的作用类似于空格。我们知道在普通的宏定义中，预处理器一般把空格
   解释成分段标志，对于每一段和前面比较，相同的就被替换。但是这样做的结果是，
   被替换段之间存在一些空格。如果我们不希望出现这些空格，就可以通过添加一些
   ##来替代空格。

另外一些分隔标志是，包括操作符，比如 +, -, *, /, [,], …，所以尽管下面的
宏定义没有空格，但是依然表达有意义的定义： define add(a, b) a+b

而其强制连接的作用是，去掉和前面的字符串之间的空格，而把两者连接起来。

2. 举列 – 试比较下述几个宏定义的区别

#define A1(name, type) type name_##type##_type 或
#define A2(name, type) type name##_##type##_type

A1(a1, int); /* 等价于: int name_int_type; */
A2(a1, int); /* 等价于: int a1_int_type; */

   解释：
        1) 在第一个宏定义中，”name”和第一个”_”之间，以及第2个”_”和第二个
   ”type”之间没有被分隔，所以预处理器会把name_##type##_type解释成3段：
   “name_”、“type”、以及“_type”，这中间只有“type”是在宏前面出现过
    的，所以它可以被宏替换。

        2) 而在第二个宏定义中，“name”和第一个“_”之间也被分隔了，所以
   预处理器会把name##_##type##_type解释成4段：“name”、“_”、“type”
   以及“_type”，这其间，就有两个可以被宏替换了。

        3) A1和A2的定义也可以如下：
           #define A1(name, type)  type name_  ##type ##_type
                                      <##前面随意加上一些空格>
           #define A2(name, type)  type name ##_ ##type ##_type

结果是## 会把前面的空格去掉完成强连接，得到和上面结果相同的宏定义

3. 其他相关 – 单独的一个 #

至于单独一个#，则表示对这个变量替换后，再加双引号引起来。比如

#define __stringify_1(x) #x
那么
__stringify_1(linux) <==> ”linux”

所以，对于MODULE_DEVICE_TABLE

     1) #define MODULE_DEVICE_TABLE(type,name)
             MODULE_GENERIC_TABLE(type##_device,name)
     2) #define MODULE_GENERIC_TABLE(gtype,name)
             extern const struct gtype##_id __mod_##gtype##_table
             __attribute__ ((unused, alias(__stringify(name))))

得到
      MODULE_DEVICE_TABLE(usb, products)
                             /*notes: struct usb_device_id products; */
<==> MODULE_GENERIC_TABLE(usb_device,products)
<==> extern const struct usb_device_id __mod_usb_device_table
             __attribute__ ((unused, alias(“products”)))

注意到alias attribute需要一个双引号，所以在这里使用了__stringify(name)来
给name加上双引号。另外，还注意到一个外部变量”__mod_usb_device_table”被alias
到了本驱动专用的由用户自定义的变量products。这个外部变量
是如何使用的，更多的信息请参看《probe()过程分析》。

4. 分析方法和验证方式 – 编写一个简单的C程序

用宏定义一个变量，同时用直接方式定义一个相同的变量，编译报告重复定义；
用宏定义一个变量，直接使用该宏定义的变量名称，编译通过且运行结果正确；

呆人 2011-03-15 13:49 发表评论

虚拟指针的问题——memset相关

呆人 — Mon, 14 Mar 2011 07:46:00 GMT

class Node
{
public:
Node(void){}
~Node(void){}
virtual bool IsLeafNode()=0;

};
class InternalNode:public Node
{
public:
InternalNode(){}
virtual ~InternalNode(void){}
virtual bool IsLeafNode(){return false;}
};

class LeafNode:public Node
{
public:
LeafNode(){}
virtual ~LeafNode(){}
virtual bool IsLeafNode(){return true;}
};

定义以上的继承结构：LeafNode和InternalNode继承自Node
有一个虚方法IsLeaf来判断是否为叶子节点。
下面有这样的测试代码：
test()
{
   Node *node = new InternalNode();
   memset(node,0,sizeof(InternalNode));
   node->IsLeafNode();
}
上述代码编译正常，而运行时出错！
出现上述问题的原因是：
对于有虚函数的类，每一个类有一个虚函数表，而每一个对象中会有一个指针指向这个虚函数表。
当   Node *node = new InternalNode();时编译器会把一个指针知道InternalNode的虚函数表
但是memset(node,0,sizeof(InternalNode));却把这个指针设成了。
所以在调用的时候出现了运行时错误！

呆人 2011-03-14 15:46 发表评论

使用位

呆人 — Tue, 04 Jan 2011 06:15:00 GMT

1 #include<windows.h>
2 #pragma pack(push,1)
3 typedef    struct    tagBite
4 {
5     UINT    bite3:8;
6     UINT    bite2:8;
7     UINT    bite1:8;
8     UINT    bite0:8;
9 }HBITE,*PHBITE;
10 typedef    union    tagDData
11 {
12     DWORD    dword;
13     BYTE    byte[4];
14     HBITE    bite;
15 }DDATA,*PDDATA;
16 #pragma pack(pop)

测试

1void testBite()
2{
3    PHBITE pHbite = new HBITE;
4    pHbite->bite0 =0;
5    pHbite->bite1 =0;
6    pHbite->bite2 =1;
7    pHbite->bite3 =1;
8
9    UINT *pData = (UINT*)pHbite;
10    printf("data=%d\n",*pData);
11
12    HBITE hBite;
13    UINT uData=10;
14    memcpy(&hBite,&uData,sizeof(uData));
15
16    printf("hBite.bite3=%d,hBite.bite2=%d\n",hBite.bite3,hBite.bite2);
17}

呆人 2011-01-04 14:15 发表评论

适合于网络传输的一种数据结构

呆人 — Tue, 21 Dec 2010 02:45:00 GMT

在网络传输中要传输的数据往往是不定长的，一般我们可以分配足够的空间，使用某个字段用于记录传输的数据的长度。然后对数据压缩后再进行传输。

定义数据结构
typedef struct tagTransferData
{
   ///一些其他信息////
   DWORD dataSize;
   char buffer[1];//定义一个可变长度的数组
}Data,*PData;
使用：
PData pData = (PData)malloc(10000);
memset(pData,0,10000);
。。。。。。。。。
char sendData[]="good morning everyone!";
strcpy(pData->buffer,sendData);
pData->dataSizse = strlen(sendData);
。。。。。。。。。
delete pData;

该数据结构:对于一块内存，开始记录了后面要传输数据的大小，紧接着是要传输的数据。是的数据比较紧凑，易于管理。
个人认为:分配的多余的空间使用数据压缩后，不会导致传输太多的无用数据。

呆人 2010-12-21 10:45 发表评论

指向类成员对象的指针

呆人 — Wed, 15 Dec 2010 06:00:00 GMT

定义:
class Shape
{
public:
//...
void moveTo(Point newLocation);
bool validate()const;
vritual bool draw() const=0;
//...
}:
class Circle: public Shape
{
//...
bool draw() const;
//...
};

void (Shape::*mf1)(Point ) = &Shape::moveTo;//指向类的成员函数的指针。

ReturnType (ClassName::*pFuncName)(paramList);
pFuncName定义了指向ClassName中的一组函数。这组函数的形式是返回值为ReturnType，函数列表为paramList.

ClassName的限定使得只有ClassName或派生自它的类的对象才能解引用这个函数指针。

  1 #include"stdafx.h"
  2 #include<stdio.h>
  3 #include<stdlib.h>
  4
  5 class Base;
  6 class Derived;
  7 typedef long (Base::*PFunc)(long,long);
  8
  9 enum FuncType
10 {
11     ADD=1,
12     SUB,
13     DIV,
14     MUL,
15 };
16
17 typedef struct tagCallBackFunc
18 {
19     long funcType;
20     PFunc proc;
21 }COMMAND,*PCOMMAND;
22
23 class Base
24 {
25 public:
26
27     virtual PCOMMAND GetCommands(void);
28     static COMMAND command[];
29
30     long base_add(long a,long b){printf("in base_add()\n");return a+b;}
31     long base_sub(long a,long b){printf("in base_sub()\n");return a-b;}
32     long base_div(long a,long b){printf("in base_div()\n");return a/b;}
33     long base_mul(long a,long b){printf("in base_mul()\n");return a*b;}
34 };
35
36 COMMAND Base::command[]={
37                        {ADD,(PFunc)&Base::base_add},
38                        {SUB,(PFunc)&Base::base_sub},
39                        {MUL,(PFunc)&Base::base_mul},
40                        {DIV,(PFunc)&Base::base_div},
41                   };
42 PCOMMAND Base::GetCommands()
43 {
44     return command;
45 }
46
47 class Derived:public Base
48 {
49 public:
50     Derived(void){}
51     ~Derived(void){}
52     virtual PCOMMAND GetCommands(void){return command;}
53
54     long add(long a,long b){printf("in add()\n");return a+b;}
55     long sub(long a,long b){printf("in sub()\n");return a-b;}
56     long div(long a,long b){printf("in div()\n");return a/b;}
57     long mul(long a,long b){printf("in mul()\n");return a*b;}
58
59     static COMMAND command[];
60 };
61
62 COMMAND Derived::command[]=
63                    {
64                        {ADD,(PFunc)&Derived::add},
65                        {SUB,(PFunc)&Derived::sub},
66                        {MUL,(PFunc)&Derived::mul},
67                        {DIV,(PFunc)&Derived::div},
68                        {0}
69                     };
70
71
72
73 void  test(Base *control,FuncType funcType,long operand1,long operand2)
74 {
75     PCOMMAND pCommand = control->GetCommands();
76     PCOMMAND pNowCommand=NULL;
77
78     for(long i=0;pCommand[i].funcType;++i)
79     {
80         if(funcType == pCommand[i].funcType)
81         {
82             pNowCommand = &pCommand[i];
83             break;
84         }
85     }
86
87     if(pNowCommand)
88     {
89         long res = (control->*pNowCommand->proc)(operand1,operand2);
90         printf("res=%d\n",res);
91     }
92 }
93
94 int main()
95 {
96     Derived *d =new Derived();
97     Base *b = (Base*)d;
98     test(b,ADD,1,2);
99
100     Base *bb = new Base;
101     test(bb,MUL,1,2);
102     delete bb;
103     delete d;
104     return 0;
105 }

第89行是对指向类成员函数的指针的解析。

呆人 2010-12-15 14:00 发表评论

数组、函数指针问题

呆人 — Wed, 15 Dec 2010 03:39:00 GMT

首先说一下数组指针和函数指针的定义问题。
一条重要的规则：函数和数组修饰符的优先级比指针修饰符的优先级高。函数的修饰符为()、数组的修饰符为[]、指针的修饰符为*。
eg:
int *A[N]: 等价于(int*)(A[N])：A[N]表示有N个元素的数组。元素类型为int*
int (*A)[N]：因为有括号提高了*的优先级。所以等价于int ((*A)[N])。表示A是一个指针。A指向的是含有N个元素的数组。数组中存放的元素为int型。

对于指向函数的指针。
int (*afp2[N])(); afp2[N]表示afp2是个含有N个元素的数组。数组中的元素为指向返回值为int、无参数的函数指针。
因为函数的声明较为复杂。可以用typedef来使代码更加明确。
我们用typedef来改写上面的声明。
typedef int (*FP)();//定义FP为返回值为int、参数列表为空的函数的类型。
FP afp2[N];//含有N个元素的数组，返回值为FP。

将一个函数的地址初始化或赋值给一个指向函数的指针时，无需显示的取其地址。编译器知道隐式的取其地址。

void*可以指向任意类型的数据。
不存在可以指向任意类型函数的通用指针。

呆人 2010-12-15 11:39 发表评论

支持任意个子女的一种树结构

呆人 — Fri, 03 Dec 2010 02:20:00 GMT

对于任意含有n个节点的有根树仅用O(n)的空间。

是一种左孩子、有兄弟的表示。
每一个节点包含下列属性：
1.指向父节点的指针
2.left-child[x]指向节点x的最左孩子
3.right-sibling[x]指向节点x紧右边的兄弟。

呆人 2010-12-03 10:20 发表评论