99久久国产亚洲高清观看2024 ,亚洲欧洲精品成人久久曰影片,99热热久久这里只有精品68

Quicker Quick-Sort

JonsenElizee — Thu, 23 Sep 2010 07:24:00 GMT

关于快速排�?/strong>

我们都知道快速排序有很好�?/font>O(nlogn)�Q�那么更快的快速排序在哪里呢？下面是我的学习记录�?/font>

�Q�－By JonsenElizee 2010/09/23

常规的快速排�?/font>

学习快速排序，最让�h熟悉的是两个ptr左右来回指，一�ơ排序后��把一�?/font>mid值放在了合适的位置上。这是我一个朋友的非递归�?/font>C�Q�＋实现。我改写一点点�Q�就是加�?/font>C�?/font>rand()来设�|�数�l��|��然后�~�译�q�行�q�个��法�Q�你可能�q�不能随随便便的写出�q�个��法�Q�但效果真的很不乐观�Q�也不知道要�q�行多久才能排序�?6*50的字�W�串。后面我们会看到一个很�_�悍的算法。。�?/font>

1 #include <stack>
2 #include <vector>
3 #include <iostream>
4 #include <stdlib.h>
5 #include <stdio.h>
6 #include <time.h>
7
8 using namespace std;
9
10 typedef struct _record
11 {
12     int begin;
13     int end;
14 }record;
15
16 void quick_sort(int a[],int len)
17 {
18     vector<record> do_job;
19     record temp;
20     temp.begin = 0;
21     temp.end = len-1;
22     do_job.push_back(temp);
23
24     while (do_job.size()  != 0) {
25         record temp = do_job.back();
26         do_job.pop_back();
27
28         int low = temp.begin;
29         int high = temp.end;
30         int key = a[low];
31         while (low < high) {
32             while(low < high && a[high] >= key) high--;
33             a[low] = a[high];
34             while(low < high && a[low] <= key) low++;
35             a[high] = a[low];
36         }
37         a[low] = key;
38
39         record temp1;
40         temp1.begin = temp.begin;
41         temp1.end = low-1;
42         if (temp1.begin < temp1.end) { do_job.push_back(temp1); }
43
44         record temp2;
45         temp2.begin = low+1;
46         temp2.end = temp.end;
47         if (temp2.begin < temp2.end) { do_job.push_back(temp2); }
48     }
49 }
50 int main()
51 {
52     int a[26*50];
53     int i = 0;
54     while(i < 26*50) a[i] = rand() % 100;
55     int count =sizeof(a) / sizeof(int);
56     quick_sort(a,count);
57     for (int i = 0; i < count; i++) cout<<a[i]<<endl;
58     return 0;
59 }
60

更简更快快速排�?/font>

�q�种快速排序不是最快的�Q�特别是基本有序时会退化到O(n^2)�Q�理��Z��Z��比较的排序不会小�?/font>O(nlogn)�Q�但�q�是有加速的可能。下面这个是�?/font>Programming Pearls 2nd》里面的�Ҏ��Q�这个算法真的很�_�悍�Q�运行完26*50的一个排序，只需�?.09�U�，我的实现如下�?/font>

�q�行时是�l�的一个长度�ؓ26*50的一个字�W�数�l�，对它�q�行排序�Q?/font>

更简更快快速排序＋�Q?/font>

研究上面��法的执行过�E�，遵��@大师的思�\�Q�我改写了算法，在我�?/font>X61�Q?/font>Redhat EL5上运行速度比上面的��法快了8倍，也就是运行完26*50长的排序�Q�只需�?.01�U�！最后我明白一个道理，要有思想�Q�要有毅力，要有实践。完�E�时�Q�我发现�q�个��法�q�有改进的余地。特和大家分享。多多指炏V�?/font>

�q�行输入�?/font>quick.c中的一��P��

�q�行�l�果�Ҏ��

常规的那个非递归的算法从我写�q�个文�g到现在，它还在运行着。。�?/font>

�W�二个和�W�三个时间对比如下图�Q?/font>

(加不加优化－O3都是一��L��l�果�Q�在我的X61上，gcc version 4.1.2 20080704 (Red Hat 4.1.2-48))

改进�?/font>myquick.c的运行时间是quick.c�?/font>1/9�?/font>

最后，我不得不�?/font>Ctrl�Q?/font>C把那个常规的�l?/font>KILL掉�?/font>

Real, User and Sys process time statistics

One of these things is not like the other. Real refers to actual elapsed time; User and Sys refer to CPU time used only by the process.
    *Real is wall clock time - time from start to finish of the call. This is all elapsed time including time slices used by other processes and time the process spends blocked (for example if it is waiting for I/O to complete).
    *User is the amount of CPU time spent in user-mode code (outside the kernel) within the process. This is only actual CPU time used in executing the process. Other processes and time the process spends blocked do not count towards this figure.
    *Sys is the amount of CPU time spent in the kernel within the process. This means executing CPU time spent in system calls within the kernel, as opposed to library code, which is still running in user-space. Like 'user', this is only CPU time used by the process.
      User+Sys will tell you how much actual CPU time your process used.

源代�?/font>

核心��法�Ҏ��?/font>

quick.c源代�?/font>

1 #include <stdio.h>
2 #include <string.h>
3 #include <stdlib.h>
4 #include <time.h>
5
6 void quick(char* str, int low, int hig);
7 void swap(char* a, char* b);
8
9 int main()
10 {
11     char ary[] = �Q�／26�Q?0长的字符串数�l�，内容参考上图�?/span>
12     char* str = ary;
13     printf("calling quick");
14     quick(str, 0, strlen(str)-1);
15     return 0;
16 }
17
18 void quick(char* str, int low, int hig) {
19     if(low >= hig) return;
20     srand(time(NULL));
21     // get a random key
22     //swap(str + low, str + low + (rand() % (hig - low + 1)));
23     int i = low, j = hig + 1, key = str[low];
24     while(1)
25     {
26         while(++i <= hig && str[i] <= key);
27         while(--j >= low && str[j] >  key);
28         if(i > j) break; // no need to do swap
29         swap(str + i, str + j);
30     }
31     swap(str + low, str + i - 1); // swap key to i-1 position
32     quick(str, low, i - 2);
33     quick(str, i, hig);
34 }
35
36 void swap(char* a, char* b) {
37     if(a == b) return;
38     *a ^= *b; *b ^= *a; *a ^= *b;
39 }
40

myquick.c源代�?/font>

1 #include <stdio.h>
2 #include <string.h>
3 #include <stdlib.h>
4 #include <time.h>
5
6 void myquick(char* str, int low, int hig);
7 void swap(char* a, char* b);
8
9 int main()
10 {
11     char ary[] = �Q�／26�Q?0长的字符�Ԍ��同quick.c的输入�?/span>
12     char* str = ary;
13     printf("calling myquick");
14     myquick(str, 0, strlen(str)-1);
15     return 0;
16 }
17
18 void myquick(char* str, int low, int hig) {
19     if(low >= hig) return;// no need to sort elements
20     // elements in the right of [m] are not sorted
21     int m = low, i = low, j = hig, key = low;
22     // skip any elements that <= [key]
23     while(i <= hig && str[i] <= str[key]) {i++; m++;}
24     // skip elements > [key]
25     while(j >= low && str[j] > str[key]) j--;
26     // initially, i==j is impossible
27     while(i <= j) {
28         // swap small one to m-position
29         if(str[i] <= str[key]) { swap(str + m++, str + i); }
30         i++;
31     }
32     swap(str + low, str + m-1);
33     myquick(str, low, m - 2);
34     myquick(str, m, hig);
35     return;
36 }
37
38 void swap(char* a, char* b) {
39     if(a == b) return;
40     *a ^= *b; *b ^= *a; *a ^= *b;
41 }
42

JonsenElizee 2010-09-23 15:24 发表评论

Difference of GDB/MI to GDBServer

JonsenElizee — Thu, 19 Aug 2010 16:47:00 GMT
    gdb and gdb/mi are essentially the same, except that gdb/mi lets you select the MI protocol version and command set to use (MI - or Machine Interface - is how Eclipse communicates with gdb, rather than using the normal gdb command-line interface). This is useful if you want to do something not supported by the defaults, or have a non-standard gdb, such as used on Mac OS X. gdbserver is a very lightweight debug server used for debugging embedded systems. The normal gdb/mi commands are used, but gdb must be told to connect to a gdbserver running on a remote system. There's an extra tab for specifying this information.

JonsenElizee 2010-08-20 00:47 发表评论

About C++ sizeof

JonsenElizee — Thu, 22 Jul 2010 04:20:00 GMT

原文作者及文章来源

1、什么是sizeof

    首先看一下sizeof在msdn上的定义�Q?/font>

    The sizeof keyword gives the amount of storage, in bytes, associated with a variable or a type (including aggregate types). This keyword returns a value of type size_t.

    看到return�q�个字眼�Q�是不是惛_��了函敎ͼ�错了�Q�sizeof不是一个函敎ͼ�你见�q�给一个函��C��参数�Q�而不加括��L��吗？sizeof可以�Q�所以sizeof不是函数。网上有��sizeof是一元操作符�Q�但是我�q�不�q�么认�ؓ�Q�因为sizeof更像一个特�D�的宏，它是在编译阶�D�|��值的。�D个例子：

cout< cout<

    在编译阶�D�已�l�被��译为：

cout<<4< cout<<1<

    �q�里有个陷阱�Q�看下面的程序：

int a = 0;
cout< cout<

    输出��Z��么是4�Q?而不是期望中�?�Q?�Q�？�Q�就在于sizeof在编译阶�D�处理的�Ҏ��。由于sizeof不能被编译成机器码，所以sizeof作用范围内，也就�?)里面的内容也不能被编译，而是被替换成�c�d��?操作�W�返回左操作数的�c�d��Q�所以a=3相当于int�Q�而代码也被替换�ؓ�Q?/font>

int a = 0;
cout<<4< cout<

    所以，sizeof是不可能支持铑ּ�表达式的�Q�这也是和一元操作符不一��L��地方�?/font>

    �l�论�Q�不要把sizeof当成函数�Q�也不要看作一元操作符�Q�把他当成一个特�D�的�~�译预处理�?/font>

2、sizeof的用�?/font>

    sizeof有两�U�用法：

    �Q?�Q�sizeof(object)
    也就是对对象使用sizeof�Q�也可以写成sizeof object 的�Ş式。例如：

    �Q?�Q�sizeof(typename)
    也就是对�c�d��使用sizeof�Q�注意这�U�情况下写成sizeof typename是非法的。下面�D几个例子说明一下：

int i = 2;
cout< cout< cout< cout< cout< cout<

    可以看出�Q�加()是永�q�正��的选择�?/font>

    �l�论�Q�不论sizeof要对谁取��|��最好都加上()�?/font>

3、数据类型的sizeof

�Q?�Q�C++固有数据�c�d��

    32位C++中的基本数据�c�d��Q�也��char,short int(short),int,long int(long),float,double, long double
大小分别是：1�Q?�Q?�Q?�Q?�Q?, 10�?/font>

    考虑下面的代码：

cout<

    unsigned影响的只是最高位bit的意义，数据长度不会被改变的�?/font>

    �l�论�Q�unsigned不能影响sizeof的取倹{�?/font>

�Q?�Q�自定义数据�c�d��

    typedef可以用来定义C++自定义类型。考虑下面的问题：

typedef short WORD;
typedef long DWORD;
cout<<(sizeof(short) == sizeof(WORD))< cout<<(sizeof(long) == sizeof(DWORD))<

    �l�论�Q�自定义�c�d��的sizeof取值等同于它的�c�d��原�Ş�?/font>

�Q?�Q�函数类�?/font>

    考虑下面的问题：

int f1(){return 0;};
double f2(){return 0.0;}
void f3(){}

cout< cout< cout< cout< cout<

    �l�论�Q�对函数使用sizeof�Q�在�~�译阶段会被函数�q�回值的�c�d��取代�Q?/font>

4、指针问�?/font>

    考虑下面问题�Q?br>
cout< cout< cout<

    可以看到�Q�不��是什么类型的指针�Q�大��都�?的，因�ؓ指针��是32位的物理地址�?/font>

    �l�论�Q�只要是指针�Q�大��就�?。（64位机上要变成8也不一定）�?/font>

    ��Z��唧唧歪歪几句�Q�C++中的指针表示实际内存的地址。和C不一��L��是，C++中取消了模式之分�Q�也��是不再有small,middle,big,取而代之的是统一的flat。flat模式采用32位实地址��d��Q�而不再是c中的 segment:offset模式。�D个例子，假如有一个指向地址 f000:8888的指针，如果是C�c�d��则是8888(16�? 只存储位�U�，省略�D?�Q�far�c�d��的C指针是f0008888(32位，高位保留�D�地址�Q�地位保留位�U?,C++�c�d��的指针是f8888(32位，相当于段地址*16 + 位移�Q�但��d��范围要更�?�?/font>

5、数�l�问�?/font>

    考虑下面问题�Q?/font>

char a[] = "abcdef";
int b[20] = {3, 4};
char c[2][3] = {"aa", "bb"};

cout< cout< cout<

    数组a的大��在定义时未指定�Q�编译时�l�它分配的空间是按照初始化的值确定的�Q�也��是7。c是多�l�数�l�，占用的空间大��是各维数的乘积�Q�也��是6。可以看出，数组的大��就是他在编译时被分配的�I�间�Q�也��是各维数的乘积*数组元素的大��?/font>

    �l�论�Q�数�l�的大小是各�l�数的乘�U?数组元素的大��?/font>

    �q�里有一个陷阱：

int *d = new int[10];

cout<

    d是我们常说的动态数�l�，但是他实质上�q�是一个指针，所以sizeof(d)的值是4�?/font>

    再考虑下面的问题：

double* (*a)[3][6];

cout< cout< cout< cout< cout<

    a是一个很奇怪的定义�Q�他表示一个指�?double*[3][6]�c�d��数组的指针。既然是指针�Q�所以sizeof(a)��是4�?/font>

    既然a是执行double*[3][6]�c�d��的指针，*a��p��C�Z��个double*[3][6]的多�l�数�l�类型，因此sizeof(*a)=3*6*sizeof(double*)=72。同��L��Q?*a表示一个double*[6]�c�d��的数�l�，所以sizeof(**a)=6*sizeof(double*)=24�?**a��p��C�其中的一个元素，也就是double*了，所以sizeof(***a)=4。至�?***a�Q�就是一个double了，所以sizeof(****a)=sizeof(double)=8�?/font>

6、向函数传递数�l�的问题�?/font>

    考虑下面的问题：
#include
using namespace std;

int Sum(int i[])
{
int sumofi = 0;
for (int j = 0; j < sizeof(i)/sizeof(int); j++) //实际上，sizeof(i) = 4
{
  sumofi += i[j];
}
return sumofi;
}

int main()
{
int allAges[6] = {21, 22, 22, 19, 34, 12};
cout< system("pause");
return 0;
}

    Sum的本意是用sizeof得到数组的大��，然后求和。但是实际上�Q�传入自函数Sum的，只是一个int �c�d��的指针，所以sizeof(i)=4�Q�而不�?4�Q�所以会产生错误的结果。解册��个问题的�Ҏ��使是用指针或者引用�?/font>

    使用指针的情况：
int Sum(int (*i)[6])
{
int sumofi = 0;
for (int j = 0; j < sizeof(*i)/sizeof(int); j++) //sizeof(*i) = 24
{
  sumofi += (*i)[j];
}
return sumofi;
}

int main()
{
int allAges[] = {21, 22, 22, 19, 34, 12};
cout< system("pause");
return 0;
}
    在这个Sum里，i是一个指向i[6]�c�d��的指针，注意�Q�这里不能用int Sum(int (*i)[])声明函数�Q�而是必须指明要传入的数组的大��，不然sizeof(*i)无法计算。但是在�q�种情况下，再通过sizeof来计��数�l�大��已�l�没有意义了�Q�因为此时大��是指定�?的�?br>使用引用的情况和指针�怼��Q?/font>

int Sum(int (&i)[6])
{
int sumofi = 0;
for (int j = 0; j < sizeof(i)/sizeof(int); j++)
{
  sumofi += i[j];
}
return sumofi;
}

int main()
{
int allAges[] = {21, 22, 22, 19, 34, 12};
cout< system("pause");
return 0;
}
    �q�种情况下sizeof的计��同��h��意义�Q�所以用数组做参敎ͼ�而且需要遍历的时候，函数应该有一个参数来说明数组的大��，而数�l�的大小在数�l�定义的作用域内通过sizeof求倹{��因此上面的函数正确形式应该是：
#include
using namespace std;

int Sum(int *i, unsigned int n)
{
int sumofi = 0;
for (int j = 0; j < n; j++)
{
  sumofi += i[j];
}
return sumofi;
}

int main()
{
int allAges[] = {21, 22, 22, 19, 34, 12};
cout< system("pause");
return 0;
}

7、字�W�串的sizeof和strlen

    考虑下面的问题：

char a[] = "abcdef";
char b[20] = "abcdef";
string s = "abcdef";

cout< cout< cout< cout< cout< cout<

a[1] = '\0';
cout< cout<

    strlen是寻找从指定地址开始，到出现的�W�一�?之间的字�W�个敎ͼ�他是在运行阶�D�|��行的�Q�而sizeof是得到数据的大小�Q�在�q�里是得到字�W�串的容量。所以对同一个对象而言�Q�sizeof的值是恒定的。string是C++�c�d��的字�W�串�Q�他是一个类�Q�所以sizeof(s)表示的�ƈ不是字符串的长度�Q�而是�c�string的大��。strlen(s)�Ҏ��是错误的，因�ؓstrlen的参数是一个字�W�指针，如果想用strlen得到s字符串的长度�Q�应该��用sizeof(s.c_str())�Q�因为string的成员函数c_str()�q�回的是字符串的首地址。实际上�Q�string�c�L��供了自己的成员函数来得到字符串的定w��和长度，分别是Capacity()和Length()。string��装了常用了字符串操作，所以在C++开发过�E�中�Q�最好��用string代替C�c�d��的字�W�串�?/font>

我注�Q�关于sizeof(string)�Q�好像不同的实现�q�回的结果不一��P��
DevCPP�Q?
VS2005�Q?2

8、从union的sizeof问题看cpu的对�?/font>

    考虑下面问题�Q�（默认寚w��方式�Q?/font>

union u
{
  double a;
  int b;
};

union u2
{
  char a[13];
  int b;
};

union u3
{
  char a[13];
  char b;
};

cout< cout< cout<

    都知道union的大��取决于它所有的成员中，占用�I�间最大的一个成员的大小。所以对于u来说�Q�大��就是最大的double�c�d��成员a了，所以sizeof(u)=sizeof(double)=8。但是对于u2和u3�Q�最大的�I�间都是char[13]�c�d��的数�l�，��Z��么u3的大��是13�Q�而u2�?6呢？关键在于u2中的成员int b。由于int�c�d��成员的存在，使u2的对齐方式变�?�Q�也��是��_��u2的大��必��d��4的对界上�Q�所以占用的�I�间变成�?6�Q�最接近13的对界）�?/font>

    �l�论�Q�复合数据类型，如union�Q�struct�Q�class的对齐方式�ؓ成员中对齐方式最大的成员的对齐方式�?/font>

    ��Z��提一下CPU对界问题�Q?2的C++采用8位对界来提高�q�行速度�Q�所以编译器会尽量把数据攑֜�它的对界上以提高内存命中率。对界是可以更改的，使用#pragma pack(x)宏可以改变编译器的对界方式，默认�?。C++固有�c�d��的对界取�~�译器对界方式与自��n大小中较��的一个。例如，指定�~�译器按2对界�Q�int�c�d��的大��是4�Q�则int的对界�ؓ2�?中较��的2。在默认的对界方式下�Q�因为几乎所有的数据�c�d��都不大于默认的对界方�?�Q�除了long double�Q�，所以所有的固有�c�d��的对界方式可以认为就是类型自�w�的大小。更改一下上面的�E�序�Q?/font>

#pragma pack(2)
union u2
{
  char a[13];
  int b;
};

union u3
{
  char a[13];
  char b;
};
#pragma pack(8)

cout< cout<

    �׃��手动更改对界方式�?�Q�所以int的对界也变成�?�Q�u2的对界取成员中最大的对界�Q�也�?了，所以此时sizeof(u2)=14�?/font>

    �l�论�Q�C++固有�c�d��的对界取�~�译器对界方式与自��n大小中较��的一个�?/font>

9、struct的sizeof问题

    因�ؓ寚w��问题使结构体的sizeof变得比较复杂�Q�看下面的例子：(默认寚w��方式�?

struct s1
{
  char a;
  double b;
  int c;
  char d;
};

struct s2
{
  char a;
  char b;
  int c;
  double d;
};

cout< cout<

    同样是两个char�c�d��Q�一个int�c�d��Q�一个double�c�d��Q�但是因为对界问题，��D��他们的大��不同。计��结构体大小可以采用元素摆放法，我�D例子说明一下：首先�Q�CPU判断�l�构体的对界�Q�根据上一节的�l�论�Q�s1和s2的对界都取最大的元素�c�d��Q�也��是double�c�d��的对�?。然后开始摆放每个元素�?br>    对于s1�Q�首先把a攑ֈ�8的对界，假定�?�Q�此时下一个空闲的地址�?�Q�但是下一个元素d是double�c�d��Q�要攑ֈ�8的对界上�Q�离1最接近的地址�?了，所以d被放在了8�Q�此时下一个空闲地址变成�?6�Q�下一个元素c的对界是4�Q?6可以满��Q�所以c攑֜��?6�Q�此时下一个空闲地址变成�?0�Q�下一个元素d需要对�?�Q�也正好落在对界上，所以d攑֜��?0�Q�结构体在地址21处结束。由于s1的大��需要是8的倍数�Q�所�?1-23的空间被保留�Q�s1的大��变成了24�?br>    对于s2�Q�首先把a攑ֈ�8的对界，假定�?�Q�此时下一个空闲地址�?�Q�下一个元素的对界也是1�Q�所以b摆放�?�Q�下一个空闲地址变成�?�Q�下一个元素c的对界是4�Q�所以取��?最�q�的地址4摆放c�Q�下一个空闲地址变成�?�Q�下一个元素d的对界是8�Q�所以d摆放�?�Q�所有元素摆攑֮�毕，�l�构体在15处结束，占用�ȝ��间�ؓ16�Q�正好是8的倍数�?/font>

    �q�里有个陷阱�Q�对于结构体中的�l�构体成员，不要认�ؓ它的寚w��方式��是他的大小�Q�看下面的例子：

struct s1
{
  char a[8];
};

struct s2
{
  double d;
};

struct s3
{
  s1 s;
  char a;
};

struct s4
{
  s2 s;
  char a;
};

cout< cout< cout< cout<

    s1和s2大小虽然都是8�Q�但是s1的对齐方式是1�Q�s2�?�Q�double�Q�，所以在s3和s4中才有这��L��差异�?/font>

    所以，在自己定义结构体的时候，如果�I�间紧张的话�Q�最好考虑寚w��因素来排列结构体里的元素�?/font>

10、不要让double�q�扰你的位域

    在结构体和类中，可以使用位域来规定某个成员所能占用的�I�间�Q�所以��用位域能在一定程度上节省�l�构体占用的�I�间。不�q�考虑下面的代码：

struct s1
{
  int i: 8;
  int j: 4;
  double b;
  int a:3;
};

struct s2
{
  int i;
  int j;
  double b;
  int a;
};

struct s3
{
  int i;
  int j;
  int a;
  double b;
};

struct s4
{
  int i: 8;
  int j: 4;
  int a:3;
  double b;
};

cout< cout< cout< cout<

    可以看到�Q�有double存在会干涉到位域�Q�sizeof的算法参考上一节）�Q�所以��用位域的的时候，最好把float�c�d��和double�c�d��攑֜��E�序的开始或者最后�?/font>

    �W�一�ơ写东西�Q�发现自��q��表达能力太差了，知道的东西讲不出来，讲出来的东西别�h也看不懂�Q�呵��c��另外，C99标准的sizeof已经可以工作在运行时了，打算最�q�找个支持C99的编译器研究一下�?/font>

JonsenElizee 2010-07-22 12:20 发表评论

My Palindrome Algorithm

JonsenElizee — Wed, 21 Jul 2010 09:19:00 GMT
Here is a simple palindrome algorithm from me.
It only can make a judge on single-byte character string.
Can anybody write a palindrome algorithm for Chinese character string? thank you at first.

JonsenElizee 2010-07-21 17:19 发表评论

Funny printf ++

JonsenElizee — Wed, 21 Jul 2010 07:19:00 GMT
The following codes are tested on VS2005.
For reply from role0523, please pay attention to compiler version and so on.
Thanks for any reply from anyone.



JonsenElizee 2010-07-21 15:19 发表评论

Potential Hazards in C/C++

JonsenElizee — Tue, 20 Jul 2010 07:44:00 GMT
Do you know all these potential hazards in C/C++?
Here is a image for all potential hazards.
Though, you would say one or more of them are not dangerous, please pay attention to them during your coding work.

JonsenElizee 2010-07-20 15:44 发表评论

99久久国产亚洲高清观看2024 ,亚洲欧洲精品成人久久曰影片,99热热久久这里只有精品68

Quicker Quick-Sort

常规的快速排�?/font>

更简更快快速排�?/font>

更简更快快速排序＋�Q?/font>

源代�?/font>

核心���法�Ҏ���?/font>

quick.c源代�?/font>

myquick.c源代�?/font>

Difference of GDB/MI to GDBServer

About C++ sizeof

My Palindrome Algorithm

Funny printf ++

Potential Hazards in C/C++

核心��法�Ҏ��?/font>