一、关键字 const volatile static define
1.关键字static的作用是什么？
这 个简单的问题很少有人能回答完全。在C语言中，关键字static有三个明显的作用：
1). 在函数体，一个被声明为静态的变量在这一函数被调用过程中维持其值不变。
2). 在模块内（但在函数体外），一个被声明为静态的变量可以被模块内所用函数访问，但不能被模块外其它函数访问。它是一个本地的全局变量。
3). 在模块内，一个被声明为静态的函数只可被这一模块内的其它函数调用。那就是，这个函数被限制在声明它的模块的本地范围内使用。
大多数应试者能正确回答第一部分，一部分能正确回答第二部分，同是很少的人能懂得第三部分。这是一个应试者的严重的缺点，因为他显然不懂得本地化数据和代码范围的好处和重要性。
2.static全局变量与普通的全局变量有什么区别？static局部变量和普通局部变量有什么区别？static函数与普通函数有什么区别？
全局变量(外部变量)的说明之前再冠以static 就构成了静态的全局变量。全局变量本身就是静态存储方式， 静态全局变量当然也是静态存储方式。
这两者在存储方式上并无不同。这两者的区别虽在于非静态全局变量的作用域是整个源程序， 当一个源程序由多个源文件组成时，非静态的全局变量在各个源文件中都是有效的。
而静态全局变量则限制了其作用域， 即只在定义该变量的源文件内有效， 在同一源程序的其它源文件中不能使用它。由于静态全局变量的作用域局限于一个源文件内，
只能为该源文件内的函数公用，因此可以避免在其它源文件中引起错误。
从以上分析可以看出， 把局部变量改变为静态变量后是改变了它的存储方式即改变了它的生存期。
把全局变量改变为静态变量后是改变了它的作用域， 限制了它的使用范围。
static函数与普通函数作用域不同。仅在本文件。只在当前源文件中使用的函数应该说明为内部函数(static)，内部函数应该在当前源文件中说明和定义。
对于可在当前源文件以外使用的函数，应该在一个头文件中说明，要使用这些函数的源文件要包含这个头文件
static全局变量与普通的全局变量有什么区别：static全局变量只初使化一次，防止在其他文件单元中被引用;
static局部变量和普通局部变量有什么区别：static局部变量只被初始化一次，下一次依据上一次结果值；
static函数与普通函数有什么区别：static函数在内存中只有一份，普通函数在每个被调用中维持一份拷贝.
3.const
const int a;
int const a; //前两个的作用是一样，a是一个常整型数。
const int *a; //a是一个指向常整型数的指针（也就是，整型数是不可修改的，但指针可以
int * const a; //a是一个指向整型数的常指针 (也就是说，指针指向的整型数是可以修改的，但指针是不可修改的）
int const * a const; //a是一个指向常整型数的常指针（也就是说，指针指向的整型数是不可修改的，同时指针也是不可修改的)
为何用const:
1). 关键字const的作用,告诉别人是只读的常量。
2). 通过给优化器一些附加的信息，使用关键字const也许能产生更紧凑的代码。
3). 合理地使用关键字const可以使编译器很自然地保护那些不希望被改变的参数，防止其被无意的代码修改。简而言之，这样可以减少bug的出现。
-----------------------
int a=248; b=4;
int const c=21;
const int *d=&a;
int *const e=&b;
int const *f const =&a;
请问下列表达式哪些会被编译器禁止？为什么？
*c=32;d=&b;*d=43;e=34;e=&a;f=0x321f;
答案：
*c 这是个什么东东，禁止
*d 说了是const， 禁止
e = &a 说了是const 禁止
const *f const =&a; 禁止
4.Volatile
谈谈你对Volatile 的理解
一个定义为volatile的变量是说这变量可能会被意想不到地改变，这样，编译器就不会去假设这个变量的值了。精确地说就是，
优化器在用到这个变量时必须每次都小心地重新读取这个变量的值，而不是使用保存在寄存器里的备份。下面是volatile变量的几个例子：
1). 并行设备的硬件寄存器（如：状态寄存器）
2). 一个中断服务子程序中会访问到的非自动变量(Non-automatic variables)
3). 多线程应用中被几个任务共享的变量
回答不出这个问题的人是不会被雇佣的。我认为这是区分C程序员和嵌入式系统程序员的最基本的问题。嵌入式系统程序员经常同硬件、中断、RTOS等等打交道，所用这些都要求volatile变量。
不懂得volatile内容将会带来灾难。
}
假设被面试者正确地回答了这是问题（嗯，怀疑这否会是这样），我将稍微深究一下，看一下这家伙是不是直正懂得volatile完全的重要性。
1). 一个参数既可以是const还可以是volatile吗？解释为什么。
2). 一个指针可以是volatile 吗？解释为什么。
3). 下面的函数有什么错误：
int square(volatile int *ptr)
{
return *ptr * *ptr;
}
下面是答案：
1). 是的。一个例子是只读的状态寄存器。它是volatile因为它可能被意想不到地改变。它是const因为程序不应该试图去修改它。
2). 是的。尽管这并不很常见。一个例子是当一个中服务子程序修该一个指向一个buffer的指针时。
3). 这段代码的有个恶作剧。这段代码的目的是用来返指针*ptr指向值的平方，但是，由于*ptr指向一个volatile型参数，编译器将产生类似下面的代码：
int square(volatile int *ptr)
{
int a,b;
a = *ptr;
b = *ptr;
return a * b;
}
由于*ptr的值可能被意想不到地该变，因此a和b可能是不同的。结果，这段代码可能返不是你所期望的平方值！正确的代码如下：
long square(volatile int *ptr)
{
int a;
a = *ptr;
return a * a;
}
5.define
用预处理指令#define 声明一个常数，用以表明1年中有多少秒（忽略闰年问题）
#define SECONDS_PER_YEAR (60 * 60 * 24 * 365)UL
我在这想看到几件事情：
1). #define 语法的基本知识（例如：不能以分号结束，括号的使用，等等）
2). 懂得预处理器将为你计算常数表达式的值，因此，直接写出你是如何计算一年中有多少秒而不是计算出实际的值，是更清晰而没有代价的。
3). 意识到这个表达式将使一个16位机的整型数溢出-因此要用到长整型符号L,告诉编译器这个常数是的长整型数。
4). 如果你在你的表达式中用到UL（表示无符号长整型），那么你有了一个好的起点。记住，第一印象很重要
6.写一个“标准”宏，这个宏输入两个参数并返回较小的一个。
. #define Min(X, Y) ((X)>(Y)?(Y):(X)) //宏中小心地把参数用括号括起来
7.不用中间变量，实现两变量的交换
#define swap(x,y) \
x=x+y;\
y=x-y;\
x=x-y //注意:结尾没有分号
8.const与#define 相比，有何优点？
const 常量有数据类型，而宏常量没有数据类型。编译器可以对前者进行类型安全检查。而对后者只进行字符替换，
没有类型安全检查，并且在字符替换可能会产生意料不到的错误。
有些集成化的调试工具可以对const 常量进行调试，但是不能对宏常量进行调试
9.inline 和define 对比
inline代码放入预编译器符号表中，高效；它是个真正的函数，调用时有严格的参数检测
二、指针和数组
1.指针数组的定义
用变量a给出下面的定义
a) 一个整型数（An integer）
b) 一个指向整型数的指针（A pointer to an integer）
c) 一个指向指针的的指针，它指向的指针是指向一个整型数（A pointer to a pointer to an integer）
d) 一个有10个整型数的数组（An array of 10 integers）
e) 一个有10个指针的数组，该指针是指向一个整型数的（An array of 10 pointers to integers）
f) 一个指向有10个整型数数组的指针（A pointer to an array of 10 integers）
g) 一个指向函数的指针，该函数有一个整型参数并返回一个整型数（A pointer to a function that takes an integer as an argument and returns an integer）
h) 一个有10个指针的数组，该指针指向一个函数，该函数有一个整型参数并返回一个整型数（ An array of ten pointers to functions that take an integer argument and return an integer ）
答案是：
a) int a; // An integer
b) int *a; // A pointer to an integer
c) int **a; // A pointer to a pointer to an integer
d) int a[10]; // An array of 10 integers
e) int *a[10]; // An array of 10 pointers to integers
f) int (*a)[10]; // A pointer to an array of 10 integers
g) int (*a)(int); // A pointer to a function a that takes an integer argument and returns an integer
h) int (*a[10])(int); // An array of 10 pointers to functions that take an integer argument and return an integer
2.引用与指针有什么区别？
1) 引用必须被初始化，指针不必。
2) 引用初始化以后不能被改变，指针可以改变所指的对象。
3) 不存在指向空值的引用，但是存在指向空值的指针。
3.char * const p; char onst * p const char *p 三个有什么区别？
char * const p; //常量指针，p的值不可以修改
char const * p; //指向常量的指针，指向的常量值不可以改
const char *p； //和char const *p
4.要对绝对地址0x100000赋值，我们可以用(unsigned int*)0x100000 = 1234; 那么要是想让程序跳转到绝对地址是0x100000去执行，应该怎么做？
答案：*((void (*)( ))0x100000 ) ( );
首先要将0x100000强制转换成函数指针,即:
(void (*)())0x100000
然后再调用它:
*((void (*)())0x100000)();
用typedef可以看得更直观些:
typedef void(*)() voidFuncPtr;
*((voidFuncPtr)0x100000)();
5.指针数组的大小
char str1[] = "abc";
char str2[] = "abc";
const char str3[] = "abc";
const char str4[] = "abc";
const char *str5 = "abc";
const char *str6 = "abc";
char *str7 = "abc";
char *str8 = "abc";
cout << ( str1 == str2 ) << endl;
cout << ( str3 == str4 ) << endl;
cout << ( str5 == str6 ) << endl;
cout << ( str7 == str8 ) << endl;
打印结果是什么？
解答：
结果是：0 0 1 1 str1,str2,str3,str4是数组变量，它们有各自的内存空间；而str5,str6,str7,str8是指针，它们指向相同的常量区域
6. 以下代码中的两个sizeof用法有问题吗？
void UpperCase( char str[] ) // 将 str 中的小写字母转换成大写字母
{
for( size_t i=0; i<sizeof(str)/sizeof(str[0]); ++i )
if( 'a'<=str[i] && str[i]<='z' )
str[i] -= ('a'-'A' );
}
char str[] = "aBcDe";
cout << "str字符长度为: " << sizeof(str)/sizeof(str[0]) << endl;
UpperCase( str );
cout << str << endl;
解答：
函数内的sizeof有问题。
根据语法，sizeof如用于数组，只能测出静态数组的大小，无法检测动态分配的或外部数组大小。
函数外的str是一个静态定义的数组，因此其大小为6，
函数内的str实际只是一个指向字符串的指针，没有任何额外的与数组相关的信息，因此sizeof作用于上只将其当指针看，一个指针为4个字节，因此返回4。
int main()
{
char a[10];
char b[] = "hello";
printf("%d\n", sizeof(a));
printf("%d\n", strlen(a));
printf("%d\n", sizeof(b));
printf("%d\n", strlen(b));
}
解答：
10 10 6 5
//strlen 遇\0 结束， \0不计入长度 所以在为char型的时候还是不一样的
7.从存储角度看，指针数组
. main()
{
int a[5]={1,2,3,4,5};
int *ptr=(int *)(&a+1);
printf("%d,%d",*(a+1),*(ptr-1));
}
输出结果是什么？
解答
输出：2,5
*(a+1）就是a[1]，*(ptr-1)就是a[4],执行结果是2，5
&a+1不是首地址+1，系统会认为加一个a数组的偏移，是偏移了一个数组的大小（本例是5个int）
int *ptr=(int *)(&a+1);
则ptr实际是&(a[5]),也就是a+5
原因如下：
&a是数组指针，其类型为 int (*)[5];
而指针加1要根据指针类型加上一定的值，不同类型的指针+1之后增加的大小不同。
a是长度为5的int数组指针，所以要加 5*sizeof(int)
所以ptr实际是a[5]
但是prt与(&a+1)类型是不一样的(这点很重要)
所以prt-1只会减去sizeof(int*)
a,&a的地址是一样的，但意思不一样
a是数组首地址，也就是a[0]的地址，&a是对象（数组）首地址，
a+1是数组下一元素的地址，即a[1],&a+1是下一个对象的地址，即a[5].
int main()
{
int a[5] = { 1, 2, 3, 4, 5 };
int *p1 = (int*)(&a + 1);
int *p2 = (int *)((int)a + 1);
printf("0x%x, 0x%x\n", p1[-1], *p2);
return 0;
}
变量a的内存地址为：0x0034fc50 问printf输出值是多少
解答
首先分析p1
&a为数组指针，类型是"int (*)[5]"，数组指针是指向数组首元素的地址的指针
&a的内存地址为：0x0034fc50
&a + 1指针加一，向后移动一个元素，这里的元素类型是"int (*)[5]"，其空间大小为20字节，因此
&a + 1的内存地址为：0x0034fc64（0x0034fc50 + 0x14）
p1的内存地址为：0x0034fc64
p1[-1]数组下标为负数，向前移动一个元素（注：数组越界在编译时与运行时都不会报错，除非操作非法内存）
p1[-1]元素所在的地址为：0x0034fc60
因此，可知p1[-1]的地址为a + 4的地址
p1[-1] == *(a + 4) == 5
继续分析p2
(int)a的值为0x0034fc50
(int)a + 1等于0x0034fc51
分析内存结构，测试环境字节序为little endian
01 00 00 00 02 00 00 00 03 00 0...
*p2等于0x2000000
8.函数调用中传递指针
#include <stdio.h>
#include <stdlib.h>
void getmemory(char *p)
{
p=(char *) malloc(100);
strcpy(p,"hello world");
}
int main( )
{
char *str=NULL;
getmemory(str);
printf("%s/n",str);
free(str);
return 0;
}
解答
程序崩溃，getmemory中的malloc 不能返回动态内存， free（）对str操作很危险
getmemory中p是形参，是一个指针变量，getmemory(str)调用后，传入的是指针变量保存的对象地址，
p=(char *) malloc(100)实际上是把申请的动态内存空间的首地址付给p指向的地址（即str指向的地址null），这个是错误的。
应该修改成指向指针的指针 void getmemory(char **p)，
这样malloc返回的地址付给*p（即str变量本身）。
void GetMemory(char **p,int num)
{ //p，指向指针的指针，*p，p指向的指针(即str)，**p，最终的对象，str指向的单元
*p=(char *)malloc(num); //申请空间首地址付给传入的被p指向的指针，即str
}
int main()
{
char *str=NULL;
GetMemory(&str,100); //传入指针变量本身的地址
strcpy(str,"hello");
free(str);
if(str!=NULL)
{
strcpy(str,"world");
}
printf("\n str is %s",str);
} .
问输出结果是什么？
解答
答案：输出str is world。
free 只是释放的str指向的内存空间,它本身的值还是存在的.所以free之后，有一个好的习惯就是将str=NULL.
此时str指向空间的内存已被回收,如果输出语句之前还存在分配空间的操作的话,这段存储空间是可能被重新分配给其他变量的,
尽管这段程序确实是存在大大的问题（上面各位已经说得很清楚了），但是通常会打印出world来。
这是因为，进程中的内存管理一般不是由操作系统完成的，而是由库函数自己完成的。
当你malloc一块内存的时候，管理库向操作系统申请一块空间（可能会比你申请的大一些），然后在这块空间中记录一些管理信息（一般是在你申请的内存前面一点），
并将可用内存的地址返回。但是释放内存的时候，管理库通常都不会将内存还给操作系统，因此你是可以继续访问这块地址的。
三、存储情况
1.内存分配方式以及它们的区别
分析：
1 从静态存储区域分配。内存在程序编译的时候就已经分配好，这块内存在程序的整个运行期间都存在。例如全局变量，static 变量。
2 在栈上创建。在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集。
3 从堆上分配，亦称动态内存分配。程序在运行的时候用malloc 或new 申请任意多少的内存，程序员自己负责在何时用free 或delete 释放内存。
动态内存的生存期由程序员决定，使用非常灵活，但问题也最多。
}
2.Heap与stack的差别。
答:Heap是堆，stack是栈。Stack的空间由操作系统自动分配/释放，Heap上的空间手动分配/释放。Stack空间有限，Heap是很大的自由存储区
C中的malloc函数分配的内存空间即在堆上,C++中对应的是new操作符。程序在编译期对变量和函数分配内存都在栈上进行,且程序运行过程中函数调用时参数的传递也在栈上进行
3.堆栈溢出
堆栈溢出就是不顾堆栈中分配的局部数据块大小，向该数据块写入了过多的数据，导致数据越界。结果覆盖了老的堆栈数据
========内存中分配
高地址|-----------
| 内核空间
|---------- 0xc0008000 内核启始地址(虚拟地址)
|stack 向下分配 //如局部变量 系统自动分配释放
|
|
|
|
|heap 向上分配 //如malloc 程序员自己负责分配释放
|.bss 未初始化的全局变量，执行文件中仅记录大小，由系统初始化 //如 int g_val;
|.data 数据段（已初始化的全局变量）则为数据分配空间，数据保存在执行文件中 //如 int g_val=3; func {static val=5;}
|.text 代码段
低地址------------
例：
#include <stdio.h>
int func (int a,int b )
{
char name[6];
int sum;
printf("Please type your name: ");
gets(name);
printf("Hello, %s!", name);
sum = a+b;
return sum;
}
int main ( )
{
func(1,2);
return 0;
}
esp 栈顶指针 //进出栈时它会变化
ebp 栈底指针
eip 指令指针
输入 Hello
------
|2 //c中函数遵循是反向压栈顺序
|1
|ret //函数的返回地址
|EBP //前一个堆栈帧的指针
|-------------------------------ebp
|name[5]
|o name[4]
|l name[3]
|l name[2]
|e name[1]
|H name[0]
|sum
--------------------------------esp
当输入 Hello AAAAAAAAAAAA 覆盖了返回地址ret，溢出
------
|A
|A
|A
|A
|o
|l
|l
|e
|H
|sum
----
堆栈用于保存临时变量，传递参数，保存线程状态。
如果堆栈溢出，可能出现打印错误信息，单步执行到了奇怪的地方。
计算函数调用树的深度，注意调用的库使用最大堆栈数。
观察堆栈使用情况。可以在内存中写入特定的字符，看那些被更改了
在堆栈的溢出去，设定警戒保护内存。如果访问到警戒内存，系统将报错
防止堆栈溢出，
利用编译器，在EBP下加检测码，当被覆盖时报错
、
4.内存泄漏
原因：
malloc free未配对
隐式内存泄漏。程序在运行过程中不停的分配内存，但是直到结束的时候才释放内存，需要运行几天才导致最终耗尽系统的所有内存
检测原理：
每当成功的分配一块内存后，就把它的指针加入一个全局的list中；每当释放一块内存，再把它的指针从list中删除。
这样，当程序结束的时候，list中剩余的指针就是指向那些没有被释放的内存
检测工具： linux用 valgrind检测
如何避免：
1. 编程阶段
×用malloc或new申请内存之后，立即检查指针值是否为NULL（防止使用指针值为NULL的内存）
×动态内存的申请与释放是否配对（防止内存泄漏）
×是否出现野指针，例如用free或delete释放了内存之后，忘记将指针设置为NULL
2. 检测工具
静态 -- BugDetective
动态 -- valgrind （可从源码中提取部分精华加入我们程序中，增加程序自检能力）
3. 编写用例
编写脚本，使最可能造成泄漏的模块运行到极限情况，把内存使用情况存入文件。最后看文件情况
5.越界
找错题
试题1：
void test1()
{
char string[10];
char* str1 = "0123456789";
strcpy( string, str1 );
}
试题2：
void test2()
{
char string[10], str1[10];
int i;
for(i=0; i＜10; i++)
{
str1[i] = 'a';
}
strcpy( string, str1 );
}
试题3：
void test3(char* str1)
{
char string[10];
if( strlen( str1 ) ＜= 10 )
{
strcpy( string, str1 );
}
}
解答：
试题1字符串str1需要11个字节才能存放下（包括末尾的’\0’），而string只有10个字节的空间，strcpy会导致数组越界；
对试题2，如果面试者指出字符数组str1不能在数组内结束可以给3分；如果面试者指出strcpy(string, str1)调用使得
从str1内存起复制到string内存起所复制的字节数具有不确定性可以给7分，在此基础上指出库函数strcpy工作方式的给10 分；
对试题3，if(strlen(str1) ＜= 10)应改为if(strlen(str1) ＜ 10)，因为strlen的结果未统计’\0’所占用的1个字节。
int main()
{
char a;
char *str=&a;
strcpy(str,"hello");
printf(str);
return 0;
}
解答
没有为str分配内存空间，将会发生异常。问题出在将一个字符串复制进一个字符变量指针所指地址。虽然可以正确输出结果，但因为越界进行内在读写而导致程序崩溃。
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main()
{
char a;
char *str = &a;
str = malloc(6*sizeof(int));
strcpy(str, "hello");
printf(str);
return 0;
}
}
6.大小端
{//请写一个C函数，若处理器是Big_endian的，则返回0；若是Little_endian的，则返回1
int checkCPU()
{
{
union w
{
int a;
char b;
} c;
c.a = 1;
return (c.b == 1);
}
}
剖析：
嵌入式系统开发者应该对Little-endian和Big-endian模式非常了解。
采用Little-endian模式的CPU对操作数的存放方 式是从低字节到高字节，而Big-endian模式对操作数的存放方式是从高字节到低字节。
例如，16bit宽的数0x1234在Little- endian模式CPU内存中的存放方式（假设从地址0x4000开始存放）为：
内存地址 存放内容
0x4000 0x34
0x4001 0x12
而在Big-endian模式CPU内存中的存放方式则为：
内存地址 存放内容
0x4000 0x12
0x4001 0x34
32bit宽的数0x12345678在Little-endian模式CPU内存中的存放方式（假设从地址0x4000开始存放）为：
内存地址 存放内容
0x4000 0x78
0x4001 0x56
0x4002 0x34
0x4003 0x12
而在Big-endian模式CPU内存中的存放方式则为：
内存地址 存放内容
0x4000 0x12
0x4001 0x34
0x4002 0x56
0x4003 0x78
联合体union的存放顺序是所有成员都从低地址开始存放，面试者的解答利用该特性，轻松地获得了CPU对内存采用Little-endian还是Big-endian模式读写
}
}
{//---字节对齐
struct s1
{
int i: 8;
int j: 4;
int a: 3;
double b;
};
struct s2
{
int i: 8;
int j: 4;
double b;
int a:3;
};
printf("sizeof(s1)= %d\n", sizeof(s1));
printf("sizeof(s2)= %d\n", sizeof(s2));
解答
16 , 24
第一个struct s1
{
int i: 8;
int j: 4;
int a: 3;
double b;
};
理论上是这样的，首先是i在相对0的位置，占8位一个字节，然后，j就在相对一个字节的位置，由于一个位置的字节数是4位的倍数，因此不用对齐，就放在那里了，
然后是a，要在3位的倍数关系的位置上，因此要移一位，在15位的位置上放下，目前总共是18位，折算过来是2字节2位的样子，由于double是8字节的，
因此要在相对0要是8个字节的位置上放下，因此从18位开始到8个字节之间的位置被忽略，直接放在8字节的位置了，因此，总共是16字节。
第二个最后会对照是不是结构体内最大数据的倍数，不是的话，会补成是最大数据的倍数。
typedef union
{
long i;
int k[5];
char c;
} DATE;
struct data
{
int cat;
DATE cow;
double dog;
} too;
DATE max;
则语句 printf("%d",sizeof(struct data)+sizeof(max));的执行结果是___,
解答
52
考点:区别struct与union.(一般假定在32位机器上)
答：DATE是一个union, 变量公用空间. 里面最大的变量类型是int[5], 占用20个字节. 所以它的大小是20. data是一个struct,
每个变量分开占用空间. 依次为int4 + DATE20 + double8 = 32. 所以结果是 20 + 32 = 52. 当然...在某些16位编辑器下,
int可能是2字节,那么结果是 int2 + DATE10 + double8 = 20
7.算法
strcpy 编写一个标准strcpy函数的总分值为10
void strcpy( char *strDest, char *strSrc ) //2分
{
while( (*strDest++ = * strSrc++) != ‘\0’ );
}
void strcpy( char *strDest, const char *strSrc ) //将源字符串加const，表明其为输入参数，加2分
{
while( (*strDest++ = * strSrc++) != ‘\0’ );
}
void strcpy(char *strDest, const char *strSrc) //对源地址和目的地址加非0断言，加3分
{
assert( (strDest != NULL) && (strSrc != NULL) );
while( (*strDest++ = * strSrc++) != ‘\0’ );
}
char * strcpy( char *strDest, const char *strSrc ) ////为了实现链式操作，将目的地址返回，加3分！
{
assert( (strDest != NULL) && (strSrc != NULL) );
char *address = strDest;
while( (*strDest++ = * strSrc++) != ‘\0’ );
return address;
}
从2分到10分的几个答案我们可以清楚的看到，小小的strcpy竟然暗藏着这么多玄机，真不是盖的！需要多么扎实的基本功才能写一个完美的strcpy啊！
}
memcpy 写一个函数，功能：完成内存之间的拷贝
void memcpy(void* pvTo, void* pvFrom, size_t size)
{
void* pbTo = (byte*)pvTo;
void* pbFrom = (byte*)pvFrom;
ASSERT(pvTo != NULL && pvFrom != NULL); //检查输入指针的有效性
ASSERT(pbTo>=pbFrom+size || pbFrom>=pbTo+size);//检查两个指针指向的内存是否重叠
while(size-->0)
*pbTo++ == *pbFrom++;
return(pvTo);
}
strcat
char * strcat (char * dst, const char * src)
{
char * cp = dst;
while( *cp )
cp++; /* find end of dst */
while( *cp++ = *src++ ) ; /* Copy src to end of dst */
return( dst ); /* return dst */
}
}
{//实现字符串倒序显示
int main()
{
char* src = "hello,world";
int len = strlen(src);
char* dest = (char*)malloc(len+1);//要为\0分配一个空间
char* d = dest;
char* s = &src[len-1];//指向最后一个字符
while( len-- != 0 )
*d++=*s--;
*d = 0;//尾部要加\0
printf("%s\n",dest);
free(dest);// 使用完，应当释放空间，以免造成内存汇泄露
return 0;
}
1万+
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
