C++博客-chenglong7997-随笔分类-CTCI_C++

intern

Snape — Sat, 01 Sep 2012 17:16:00 GMT

1.软件p4, vs, vim, cscope.
fix step：
先reproduce
再确定出现问题的函数，行号
分析原因
fix

vs中远程调试，指定ip，port，同时在远程主机上要同意远程调试，接受指定user。要保证code与exe文件一致。
设定断点，观察debug输入，与预想的有什么不同。观察bt，thread stack 找到出现问题的函数或者行号。

p4 中的check out, commit, diff, opened, edit， sync命令和作用。
submit step：merge changlist (from branch) (to branch)
check diff
resolve
make (so make sure the code is right)
submit (add comments)
set the bug state in Web

vim:熟悉了各种命令。

cscope，ctag：在linux中浏览代码很有用，可以找到function definition, struct definition, calling function, called function.

在一个目录中建立cscope database，可以再主目录建立，之后只在这里使用cscope，就能找到全部引用。

linux， lib 文件的使用。有.a 和.o的lib文件。

2.code style.
文件命名要有层次感。例如，snape_webserver_msg.c, snape_webserver_thread.c, snape_webserver_log.c, snape_client_msg.c,,,
函数命名也要有层次感，例如，snape_webserver_msg_set_connection(), snape_webserver_thread_create(),snape_client_request_get_pic().
变量命名也要有层次感和意义。
出错处理的专门函数。
debug level：debug，info, basic, webserver, client,,,

3.函数的定义与浏览。
call graph definition.
函数名字最好能够显示出函数调用的graph。
使用hash table 保存大量类型的数据。
使用内容的md5作为这个内容的id，就可以完美配合hash table。

4.thread， process
windows 中， object , event, cs
cs同步速度较快，但是使用cs容易进入deadlock状态。因为在等待进入cs时，无法设定超时值。
互斥对象与内核对象属于内核对象，利用内核对象进行线程同步，同步速度较慢，但这种方式可在多个进程的各个对象之间进行同步。
event分为人工重置与自动重置事件，两者在细节上，不同。

5.cache implementation
client端可以使用类似os中，cache 与虚拟内存的方法。b_modified表示是否经过更改，从而是否需要更新。每次只去拿新的东西。
而在server端，可以使用内容的MD5判断是否需要处理来到的内容，可以用多层次的MD5来更加去improve performance。例如用总体的md5，和各个部分的md5.
先判断总体MD5，如果改变，在去检查部分md5.如果没有改变，就整个都可以丢弃，不去处理。
design is very important. 代码的执行过程要完全依赖design。

6.select function
异步select，可以让线程不去busy waiting。
但是如果需要传输内容，需要trigger signal，让它不用等到timeout，就能发送数据。

7.timestamp/timeout/ ts_diff
可以用ts_diff去同步时间。
使用timeout来防止任意操作的无限制等待
使用timestamp来决定哪一个更新。不要用counter。（无法同步，无法控制单一性）

8.xml api
在传送数据方面，可以使用xml

9.performace/memory usage
mm tools.

Snape 2012-09-02 01:16 发表评论

C/C++ 2D数组的动态分配方法比较

Snape — Mon, 26 Mar 2012 17:20:00 GMT

方法1:

1 #include
2 using namespace std;
3
4 //by snape 2012-3-25
5 //method 1: drawback is we need calculate the one-dimensional index to access the 2D array
6 int main()
7 {
8     int rowSize, colSize, totalSize;
9     int index, i,j;
10
11     cout<<"Enter the row and column size for your 2D array!"<12     cin>>rowSize>>colSize;
13
14     totalSize=rowSize*colSize;
15     int *pArray;
16     pArray=new int[totalSize];
17
18     //file  the array with integers from 0 to totalsize
19     //file across the rows, moving down the colums
20
21     int arrayValue=0;
22     for(i=0; i//outer-loop traverse down the "rows"
23     {
24         for(j=0; j25         {
26             //caculate array index
27             //index=rowSize*j+i;        //both index=rowSize*j+i; and index=colSize*i+j; are ok
28             index=colSize*i+j;            //but if index=rowsize*i+j; or index=colSize*j+i; then there will be a bug.
29             pArray[index]=arrayValue;    // i like index=colSize*i+j; since the arrange of 2D is according to rows
30             cout<<"index="<31             cout<<"i(row)="<32             ++arrayValue;
33         }
34     }
35
36     //output the array
37     for(int k=0; k38     {
39         cout<40     }
41     cout<<"The End"<42     delete [] pArray;
43     return 0;
44 }
45
46

方法2：

1 //by snape
2 //method 2: better than method 1, but call new twice
3 int main()
4 {
5     int rowSize, colSize, totalSize;
6     int i, j;
7     cout<<"Enter the row and column size for your 2D array"< 8     cin>>rowSize>>colSize;
9
10     totalSize=rowSize*colSize;
11
12     int *pArray; //pointer to an integer
13     int **pPointerArray; //pointer to an integer pointer
14
15     pArray=new int[totalSize];    //memory for totalSize integers
16     pPointerArray=new int*[rowSize];    //memory for rowSize # of int pointers
17
18     //fill the pointer array with the pArray[i][0] address
19     for(i=0; i20         pPointerArray[i]=pArray+i*colSize;    //place the address into the pointer
21
22     //now fill the pArray by using the pPointerArray to access elements
23     int arrayValue=0;
24     for(i=0; i25     {
26         for(j=0; j27         {
28             pPointerArray[i][j]=arrayValue;    //cool
29             cout<<"i(row)="<30             ++arrayValue;
31         }
32     }
33
34         //output the array
35     for(int k=0; k36     {
37         cout<38     }
39     cout<<"The End!"<40     delete [] pArray;
41     delete [] pPointerArray;
42     return 0;
43 }

方法3：

1 // by snape
2 //method 3: better than method 2. just malloc once and the memory is contiguous block. the best
3 int **my2DAlloc(int rowSize, int colSize)
4 {
5     int i;
6     int header=rowSize * sizeof(int *);
7     int data=rowSize * colSize * sizeof(int);
8     int **rowptr=(int **)malloc(header+data);    //malloc memory for both data and pointerArray(the header)
9
10     if(rowptr==NULL)
11         return NULL;
12     int *buf=(int *)(rowptr+rowSize);    //buf: the pointer to the first data
13     for(i=0; i//assign the address of each row to pointerArray(the header)
14         rowptr[i]=buf+i*colSize;
15
16     return rowptr;
17 }
18
19 int main()
20 {
21     cout<<"Enter the row and column size for your 2D array"<22     int rowSize, colSize;
23     cin>>rowSize>>colSize;
24     int **p=my2DAlloc(rowSize, colSize);
25
26     //assign values
27     int i, j, arrayValue=0;
28     for(i=0; i29         for(j=0; j30             p[i][j]=arrayValue++;
31
32     //output values
33     for(i=0; i34         for(j=0; j35             cout<36
37     free((void *)p);
38 }

方法3，我感觉最好，只调用一次malloc，空间连续，释放内存也比较方便。

大家有什么想法的欢迎交流

Snape 2012-03-27 01:20 发表评论

C 边界对齐的malloc和free函数实现

Snape — Mon, 26 Mar 2012 17:19:00 GMT

MSVC 下面有：

1
2 void * _aligned_malloc(
3 size_t size,
4 size_t alignment
5 );

Unix/Linux下面有：

1 int posix_memalign(void **memptr, size_t alignment, size_t size);

自己实现：

1 #include
2 #include
3 using namespace std;
4
5 //by snape 2012-3-25
6
7 void *aligned_malloc(size_t required_bytes, size_t alignment)
8 {
9     void *p1;    //orignal block
10     void **p2;    //aligned block
11
12     int offset=alignment-1+sizeof(void*);
13     if( (p1=(void*)malloc(required_bytes+offset))==NULL )
14         return NULL;
15     //cast void* to void** to let p1 store into heap in the form of pointer
16     p2=(void**)( ((size_t)(p1)+offset) & ~(alignment-1) );    //add offset to p1 and then back to the aligned address
17     p2[-1]=p1;
18     return p2;
19 }
20
21 void aigned_free(void *p2)
22 {
23     void* p1=((void**)p2)[-1];    //get the p1
24     free(p1);
25 }
26
27
28
29 int main()
30 {
31     int size=10, align=16;
32     int *p=(int *)aligned_malloc(size, align);
33
34     cout<<"The start address="<35
36     aigned_free(p);
37 }

上面实现很考验对指针的掌握。原理不是很难。

Line12：分配内存的时候，加上alignment-1个空间，就能保证能够找到和alignment对齐的开始地址。多出来的sizeof（void*）是为了保存malloc最初返回的指针p1而分配的一个空间

Line 17: 保存原始的malloc返回的地址p1到对齐地址的前一个空间

Snape 2012-03-27 01:19 发表评论