1     char str[256] = { 0 };
 2     int data = 1024;
 3     //将data转换为字符串
 4     sprintf(str,"%d",data);
 5     //获取data的十六进制
 6     sprintf(str,"0x%X",data);
 7     //获取data的八进制
 8     sprintf(str,"0%o",data);
 9     const char *s1 = "Hello";
10     const char *s2 = "World";
11     //连接字符串s1和s2
12     sprintf(str,"%s %s",s1,s2);

sscanf可以支持格式字符%[]：

 1     const char *s = "http://www.baidu.com:1234";
 2     char protocol[32] = { 0 };
 3     char host[128] = { 0 };
 4     char port[8] = { 0 };
 5     sscanf(s,"%[^:]://%[^:]:%[1-9]",protocol,host,port);
 6
 7     printf("protocol: %s\n",protocol);
 8     printf("host: %s\n",host);
 9     printf("port: %s\n",port);
10     

Sprintf:
sprintf 是个变参函数，定义如下：
int sprintf( char *buffer, const char *format [, argument] ... );
除了前两个参数类型固定外，后面可以接任意多个参数。而它的精华，显然就在第二个参数：
格式化字符串上。

fprintf():
　　按格式输入到流，其原型是int fprintf(FILE *stream, const char *format[, argument, ...]);其用法和printf()相同，不过不是写到控制台，而是写到流罢了
例：fprintf(fp,"%2d%s",4,"Hahaha");

fscanf():
　　从流中按格式读取，其原型是int fscanf(FILE *stream, const char *format[, address, ...]);其用法和scanf()相同，不过不是从控制台读取，而是从流读取罢了。
例：fscanf(fp,"%d%d" ,&x,&y);

fscanf,sscanf,fprintf,sprintf之间的区别是什么

f开头代表 file

继承性

在设计C语言继承性的时候，我们需要做的就是把基础数据放在继承的结构的首位置即可。这样，不管是数据的访问、数据的强转、数据的访问都不会有什么问题。

1. typedef struct _Organizer
2. {
3. int number;
4. Action* pActionHead;  //结构体里面存放其他结构体
5. Action* (*create)();  //结构体里面存放函数的方式
6. void (*restore)(struct _Organizer* pOrganizer);   //结构体里面存放函数的方式
7. }Organizer;

1. void restore(struct _Organizer* pOrganizer)
2. {
3. Action* pHead;
4. assert(NULL != pOrganizer);
5. pHead = pOrganizer->pActionHead;
6. pHead->process(pHead->pData);
7. pOrganizer->pActionHead = pHead->next;
8. pOrganizer->number --;
9. free(pHead);
10. return;
11. }

对于一个希望配置intel cpu，samsung 内存、日立硬盘的朋友。他可以这么设计，

而对于一个希望配置AMD cpu, kingston内存、西部数据硬盘的朋友。他又该怎么做呢？

假设有两个水果店都在卖水果，都卖苹果和葡萄。其中一个水果店买白苹果和白葡萄，另外一个水果店卖红苹果和红葡萄。所以说，对于水果店而言，尽管都在卖水果，但是两个店卖的品种不一样。

既然水果不一样，那我们先定义水果。

上面分别对苹果和葡萄进行了抽象，当然它们的具体函数也是不一样的。

完成了水果函数的定义。下面就该定义工厂了，和水果一样，我们也需要对工厂进行抽象处理。

所以，对于卖白苹果、白葡萄的水果店就该这样设计了，红苹果、红葡萄的水果店亦是如此。

这样，基本的框架就算搭建完成的，以后创建工厂的时候，

下面我们主要从两个方面对头文件进行分析，即头文件是做什么的，头文件编写的过程中要注意些什么？

（1）头文件的作用

其实很多的编程语言是没有头文件的，比如说C#、java语言。为什么呢，因为这些语言数据结构和函数操作是捆绑在一起的。而C语言则不一样，它是把头文件和实现文件分开来的。头文件的内容主要有哪些呢，也就是嵌套头文件、宏定义、数据类型、函数原型定义、static函数等等。

（2）头文件的编写

a）头文件要简洁

很多源文件在编写的时候常常喜欢添加很多的头文件，不管是需要的还是不需要的。可是，我们要知道，头文件的作用主要是定义数据类型和函数类型的。本质上来说，头文件很少会创建实质性的代码，不管是数据段的内容，还是代码段的内容。简洁的头文件不仅有利于快速排除编译故障，还能提高编译的速度。有经验的朋友都知道，源文件的编译错误比较容易解决，而头文件的编译错误常常十分复杂。所以，我们必须在一切可能的条件下保证头文件的简洁。

b）头文件注意互斥性

注意头文件的互斥性，需要我们在开发中养成良好的编程习惯。不管是创建头文件，首先要做的事情就是添加编译宏。看上去这是一个十分不起眼的举动，但是常常可以帮助你减少许多不必要的麻烦。

c）全局变量不要在头文件里面定义，如果是外部引用，必须添加上extern

d）不要在头文件里面实现函数，如果要实现，也必须要添加static

e）头文件当中如果需要嵌入别的头文件，那么只是为了引用另外一个头文件的数据结构

f）头文件中引用的数据类型如果没有说明，那么在被源文件引用的时候，只要保证其他的头文件存在这个数据类型定义即可

g）源文件引用头文件的时候需要注意头文件的顺序，有的时候顺序变了，可能编译就失败了。原因就是之前后面头文件中定义的数据类型找不到出处了

h）某些工程没有把头文件和源文件绑定在一起，修改头文件必须删除工程重新编译

i）头文件的存在只是为了源文件才存在的，如果没有必要不要写头文件。要写，影响范围也要控制在最小的范围内

j）如果头文件定义了数据结构，那么需要嵌入引用头文件，反之如果只是指针，声明一下即可，比如说

k）如果有可能经常整理自己的头文件，全部删除再一个一个添加，这样就知道哪些是我们需要的，哪些不是

l）对于某些宏，如果不确定文件本身是在哪里定义的，可以在源文件中再定义一次，这样编译器就会精确提示我们原来这个宏是在那里定义的

好了，差不多就这么多了。

头文件 *.h文件例子：

1. #ifndef _DATA_H
2. #define _DATA_H
3. #endif

源文件*.c文件例子：

1. #include <pthread.h>
2. #include <semaphore.h>
3. #include <stdio.h>
4. #include <stdlib.h>
5. // Set either of these to 1 to prevent CPU reordering
6. #define USE_CPU_FENCE              0
7. #define USE_SINGLE_HW_THREAD       0  // Supported on Linux, but not Cygwin or PS3
8. #if USE_SINGLE_HW_THREAD       ---------在头文件中使用if ... endif
9. #include <sched.h>
10. #endif
11. //-------------------------------------
12. //  MersenneTwister
13. //  A thread-safe random number generator with good randomness
14. //  in a small number of instructions. We'll use it to introduce
15. //  random timing delays.
16. //-------------------------------------
17. #define MT_IA  397
18. #define MT_LEN 624
19. class MersenneTwister
20. {
21. unsigned int m_buffer[MT_LEN];
22. int m_index;
23. public:
24. MersenneTwister(unsigned int seed);
25. // Declare noinline so that the function call acts as a compiler barrier:
26. unsigned int integer() __attribute__((noinline));
27. };
28. MersenneTwister::MersenneTwister(unsigned int seed)
29. {
30. // Initialize by filling with the seed, then iterating
31. // the algorithm a bunch of times to shuffle things up.
32. for (int i = 0; i < MT_LEN; i++)
33. m_buffer[i] = seed;
34. m_index = 0;
35. for (int i = 0; i < MT_LEN * 100; i++)
36. integer();
37. }
38. unsigned int MersenneTwister::integer()
39. {
40. // Indices
41. int i = m_index;
42. int i2 = m_index + 1; if (i2 >= MT_LEN) i2 = 0; // wrap-around
43. int j = m_index + MT_IA; if (j >= MT_LEN) j -= MT_LEN; // wrap-around
44. // Twist
45. unsigned int s = (m_buffer[i] & 0x80000000) | (m_buffer[i2] & 0x7fffffff);
46. unsigned int r = m_buffer[j] ^ (s >> 1) ^ ((s & 1) * 0x9908B0DF);
47. m_buffer[m_index] = r;
48. m_index = i2;
49. // Swizzle
50. r ^= (r >> 11);
51. r ^= (r << 7) & 0x9d2c5680UL;
52. r ^= (r << 15) & 0xefc60000UL;
53. r ^= (r >> 18);
54. return r;
55. }
56. //-------------------------------------
57. //  Main program, as decribed in the post
58. //-------------------------------------
59. sem_t beginSema1;
60. sem_t beginSema2;
61. sem_t endSema;
62. int X, Y;
63. int r1, r2;
64. /* thread1Func, thread2Func for StoreLoad */
65. /* thread3Func, thread4Func for StoreStore LoadLoad */
66. /* thread5Func, thread6Func for LoadStore */
67. void *thread1Func(void *param)
68. {
69. MersenneTwister random(1);
70. for (;;)
71. {
72. sem_wait(&beginSema1);  // Wait for signal
73. while (random.integer() % 8 != 0) {}  // Random delay
74. // ----- THE TRANSACTION! -----
75. X = 1;
76. #if USE_CPU_FENCE                    ---------在子函数中使用if ... endif
77. asm volatile("mfence" ::: "memory");  // Prevent CPU reordering
78. #else
79. asm volatile("" ::: "memory");  // Prevent compiler reordering
80. #endif
81. r1 = Y;
82. sem_post(&endSema);  // Notify transaction complete
83. }
84. return NULL;  // Never returns
85. };
86. void *thread2Func(void *param)
87. {
88. MersenneTwister random(2);
89. for (;;)
90. {
91. sem_wait(&beginSema2);  // Wait for signal
92. while (random.integer() % 8 != 0) {}  // Random delay
93. // ----- THE TRANSACTION! -----
94. Y = 1;
95. #if USE_CPU_FENCE
96. asm volatile("mfence" ::: "memory");  // Prevent CPU reordering
97. #else
98. asm volatile("" ::: "memory");  // Prevent compiler reordering
99. #endif
100. r2 = X;
101. sem_post(&endSema);  // Notify transaction complete
102. }
103. return NULL;  // Never returns
104. };
105. void *thread3Func(void *param)
106. {
107. MersenneTwister random(1);
108. for (;;)
109. {
110. sem_wait(&beginSema1);  // Wait for signal
111. while (random.integer() % 8 != 0) {}  // Random delay
112. // ----- THE TRANSACTION! -----
113. X = 1;
114. #if USE_CPU_FENCE
115. asm volatile("mfence" ::: "memory");  // Prevent CPU reordering
116. #else
117. asm volatile("" ::: "memory");  // Prevent compiler reordering only
118. #endif
119. Y = 1;
120. sem_post(&endSema);  // Notify transaction complete
121. }
122. return NULL;  // Never returns
123. };
124. void *thread4Func(void *param)
125. {
126. MersenneTwister random(2);
127. for (;;)
128. {
129. sem_wait(&beginSema2);  // Wait for signal
130. while (random.integer() % 8 != 0) {}  // Random delay
131. // ----- THE TRANSACTION! -----
132. r1 = Y;
133. #if USE_CPU_FENCE
134. asm volatile("mfence" ::: "memory");  // Prevent CPU reordering
135. #else
136. asm volatile("" ::: "memory");  // Prevent compiler reordering only
137. #endif
138. r2 = X;
139. sem_post(&endSema); // Notify transaction complete
140. }
141. return NULL;  // Never returns
142. };
143. void *thread5Func(void *param)
144. {
145. MersenneTwister random(1);
146. for (;;)
147. {
148. sem_wait(&beginSema1);  // Wait for signal
149. while (random.integer() % 8 != 0) {}  // Random delay
150. // ----- THE TRANSACTION! -----
151. r1 = X;
152. #if USE_CPU_FENCE
153. asm volatile("mfence" ::: "memory");  // Prevent CPU reordering
154. #else
155. asm volatile("" ::: "memory");  // Prevent compiler reordering only
156. #endif
157. Y = 1;
158. sem_post(&endSema);  // Notify transaction complete
159. }
160. return NULL;  // Never returns
161. };
162. void *thread6Func(void *param)
163. {
164. MersenneTwister random(2);
165. for (;;)
166. {
167. sem_wait(&beginSema2);  // Wait for signal
168. while (random.integer() % 8 != 0) {}  // Random delay
169. // ----- THE TRANSACTION! -----
170. r2 = Y;
171. #if USE_CPU_FENCE
172. asm volatile("mfence" ::: "memory");  // Prevent CPU reordering
173. #else
174. asm volatile("" ::: "memory");  // Prevent compiler reordering only
175. #endif
176. X = 1;
177. sem_post(&endSema);  // Notify transaction complete
178. }
179. return NULL;  // Never returns
180. };
181. int main(int argc, char** argv)
182. {
183. // Check Argument
184. if (argc > 2)
185. {
186. printf("Too Many Arguments: Only Need One.\n");
187. return 0;
188. }
189. if (argc == 1)
190. {
191. printf("You Should Give an Argument: 1 or 2 or 3.\n");
192. return 0;
193. }
194. int i;
195. i = atoi(argv[1]);
196. if (i < 1 || i > 3)
197. {
198. printf("Wrong Argument: Only 1 or 2 or 3 Can be Input.\n");
199. return 0;
200. }
201. // Initialize the semaphores
202. sem_init(&beginSema1, 0, 0);
203. sem_init(&beginSema2, 0, 0);
204. sem_init(&endSema, 0, 0);
205. // Spawn the threads
206. pthread_t thread1, thread2;
207. // 1. StoreLoad Reorder Tests
208. if (i == 1)
209. {
210. pthread_create(&thread1, NULL, thread1Func, NULL);
211. pthread_create(&thread2, NULL, thread2Func, NULL);
212. }
213. // 2. LoadLoad && StoreStore Reorder Tests
214. else if (i == 2)
215. {
216. pthread_create(&thread1, NULL, thread3Func, NULL);
217. pthread_create(&thread2, NULL, thread4Func, NULL);
218. }
219. // 3. LoadStore Reorder Tests
220. else
221. {
222. pthread_create(&thread1, NULL, thread5Func, NULL);
223. pthread_create(&thread2, NULL, thread6Func, NULL);
224. }
225. #if USE_SINGLE_HW_THREAD               ---------在main函数中调用if ... endif
226. // Force thread affinities to the same cpu core.
227. cpu_set_t cpus;
228. CPU_ZERO(&cpus);
229. CPU_SET(0, &cpus);
230. pthread_setaffinity_np(thread1, sizeof(cpu_set_t), &cpus);
231. pthread_setaffinity_np(thread2, sizeof(cpu_set_t), &cpus);
232. #endif
233. // Repeat the experiment ad infinitum
234. int detected = 0;
235. for (int iterations = 1; ; iterations++)
236. {
237. // Reset X and Y
238. X = 0;
239. Y = 0;
240. // Signal both threads
241. sem_post(&beginSema1);
242. sem_post(&beginSema2);
243. // Wait for both threads
244. sem_wait(&endSema);
245. sem_wait(&endSema);
246. // Check if there was a simultaneous reorder
247. // 1. StoreLoad Reorder
248. if (i == 1)
249. {
250. if (r1 == 0 && r2 == 0)
251. {
252. detected++;
253. printf("%d reorders detected after %d iterations\n", detected, iterations);
254. }
255. }
256. // 2. LoadLoad && StoreStore Reorder
257. else if (i == 2)
258. {
259. if (r1 == 1 && r2 == 0)
260. {
261. detected++;
262. printf("%d reorders detected after %d iterations\n", detected, iterations);
263. }
264. }
265. // 3. LoadStore Reorder
266. else
267. {
268. if (r1 == 1 && r2 == 1)
269. {
270. detected++;
271. printf("%d reorders detected after %d iterations\n", detected, iterations);
272. }
273. }
274. }
275. return 0;  // Never returns
276. }

嵌套For循环性能优化案例

某日，在JavaEye上看到一道面试题，题目是这样的：请对以下的代码进行优化

Java代码  

1. for (int i = 0; i < 1000; i++)
2. for (int j = 0; j < 100; j++)
3. for (int k = 0; k < 10; k++)
4. testFunction (i, j, k);

应用：不借助第三个数交换两数，有趣应用4

乘除法运算要用移位的方式，效率更高---->>,<<

前言：

我们在写程序的时候，总是或多或少会加入一些printf之类的语句用于输出调试信息，但是printf语句有个很不方便的地方就是当我们需要发布程序的时候要一条一条的把这些语句删除，而一旦需要再次调试的时候，这些语句又不得不一条条的加上，这给我们带来了很大的不便，浪费了我们很多的时间，也造成了调试的效率低下。所以，很多人会选择使用宏定义的方式来输出调试语句。

比如，定义一个宏开关：

#define __DEBUG

当需要调试的时候，使用语句：

#ifdef __DEBUG

printf(xxx);

#endif

这种方式的调试，可以通过undef __DEBUG的方式让告知编译器不编译这些语句，从而不再输出这些语句。但是这种方式的麻烦之处也是显而易见的，每一条调试语句都需要使用两条宏定义来包围，这不但在代码的编写上不便，源码结构也不好看，工作量依然不小。

如果我们能够把这三条语句编程一条，那该多舒服呀~，于是，我们想到使用这样的语句：

#ifdef __DEBUG

#define DEBUG(info)    printf(info)

#else

#define DEBUG(info)

#endif

这样，我们在编写代码的时候，使用DEBUG一条语句就可以了，我们把宏开关__DEBUG打开，所有的DEBUG(info)宏定义信息都会被替换为printf(info)，关上则会被替换成空，因此不会被编译。嗯，这次方便多了，一条语句就可以了~~~ 但是，问题也随之而来了，printf是支持多个参数的，而且是不定参数，当你使用下面这样的语句时就会报错：

DEBUG("%s",msg)

这是因为，DEBUG(info)这条宏定义只支持一个参数的替换。

因此，我们希望DEBUG能够像printf那样，支持多个参数，并且这些参数刚好展开成为printf语句本身使用的参数，譬如：我们希望DEBUG("%s",msg)能够展开为printf("%s",msg)

正文：

通过网上的资料查阅，发现自C99规范以后，编译器就开始支持不定参数的宏定义，就像printf一样。

大家可以看看这篇文章：http://blog.csdn.net/aobai219/archive/2010/12/22/6092292.aspx

于是，我们定义了一个这样的东东：

#define DEBUG(format, ...) printf (format, ##__VA_ARGS__)（' ## '的意思是，如果可变参数被忽略或为空，将使预处理器（ preprocessor ）去除掉它前面的那个逗号。）

于是乎，我们神奇地发现，DEBUG完全取代了printf，所有的DEBUG(…)都被完成的替换成了printf(…)，再也不会因那个可恶的逗号而烦恼了。

但是，我们发现，光有printf还不够，虽然调试信息是输出了，可是很多的调试信息输出，我们并不能一下子知道这条信息到底是在那里打印出来的，于是，我们又想，能不能把当前所在文件名和源码行位置也打印出来呢，这样不就一目了然了吗，哪里还用的着去想，去找调试信息在哪里输出的呢，都已经打印出来了！

于是我们就有了下面的故事。。。

编译器内置宏：

先介绍几个编译器内置的宏定义，这些宏定义不仅可以帮助我们完成跨平台的源码编写，灵活使用也可以巧妙地帮我们输出非常有用的调试信息。

ANSI C标准中有几个标准预定义宏（也是常用的）：

__LINE__：在源代码中插入当前源代码行号；

__FILE__：在源文件中插入当前源文件名；

__DATE__：在源文件中插入当前的编译日期

__TIME__：在源文件中插入当前编译时间；

__STDC__：当要求程序严格遵循ANSI C标准时该标识被赋值为1；

__cplusplus：当编写C++程序时该标识符被定义。

编译器在进行源码编译的时候，会自动将这些宏替换为相应内容。

看到这里，你的眼睛应该一亮了吧，嗯，是的，__FILE__和__LINE__正是我们前面想要的输出的，于是，我们的每一条语句都变成了：

DEBUG("FILE: %s, LINE: %d…",__FILE__,__LINE__,…)

其实没有必要，__FILE__本身就会被编译器置换为字符常量，于是乎我们的语句又变成了这样：

DEBUG("FILE:"__FILE__", LINE: %d…",__LINE__,…)

但是，我们还是不满足，依然发现，还是很讨厌，为什么每条语句都要写"FILE:"__FILE__", LINE: %d 以及,__LINE,这两个部分呢？这不是浪费我们时间么？

哈哈，是的，这就是本次大结局，把DEBUG写成这样：

DEBUG(format,...) printf("FILE: "__FILE__", LINE: %d: "format"/n", __LINE__, ##__VA_ARGS__)

没错，就是这样！下面，所有的DEBUG信息都会按照这样的方式输出：

FILE: xxx, LINE: xxx, …….

最后：

最后，老规矩，coding测试。

测试结果：

是不是感觉很酷？O(∩_∩)O哈哈~

事实上，一般来说malloc的数据是不需要我们监督的，因为内存分配的时候，通常库函数会比我们要求的size多分配几个字节，这样在free的时候就可以判断内存的开头和结尾处有没有指针溢出。朋友们可以试一下下面这段代码。

pMem[-1] = 100是堆左溢出， pMem[100]是堆右溢出

1.获得int型最大值

另一种写法

C语言版

4.乘以2运算

9.不用临时变量交换两个数（面试常考）

C语言 版

14.计算2的n次方

1.获得int型最大值

另一种写法

C语言版

4.乘以2运算

9.不用临时变量交换两个数（面试常考）

C语言 版

14.计算2的n次方

 用vfork()创建子进程，执行后程序一直不断地重复运行，不断创建子进程，结尾用exit(0)代替return(0)后问题就能解决

<span style="color:#ff0000;">return 0在一个函数中是正常的返回过程，它会使得程序返回到函数被调用处，回复之前的执行流程，return 语句不会被执行。而exit 一般是在任意位置和使用的，执行到exit 0时，整个进程就over了（这也是为什么在多线程程序中不要随意使用exit的原因），用来使程序退出运行，一般用来处理（不可挽回的）错误状态。</span>

<span style="color: rgb(51, 51, 51);">        指令             用途</span><span style="color:#ff0000;">      #           空指令，无任何效果#include    包含一个源代码文件#define     定义宏#undef      取消已定义的宏#if         如果给定条件为真，则编译下面代码#ifdef      如果宏已经定义，则编译下面代码#ifndef     如果宏没有定义，则编译下面代码#elif       如果前面的#if给定条件不为真，当前条件为真，则编译下面代码#endif      结束一个#if……#else<a target=_blank target="_blank" href="https://www.baidu.com/s?wd=%E6%9D%A1%E4%BB%B6%E7%BC%96%E8%AF%91&tn=44039180_cpr&fenlei=mv6quAkxTZn0IZRqIHckPjm4nH00T1d9mWTvnAfsnHbzuyD1rj0L0AP8IA3qPjfsn1bkrjKxmLKz0ZNzUjdCIZwsrBtEXh9GuA7EQhF9pywdQhPEUiqkIyN1IA-EUBtkrHm3PjTdn6" class="baidu-highlight" rel="nofollow" style="text-decoration: none;">条件编译</a>块#error      停止编译并显示错误信息</span>