1.char *strcpy(char *dest,const char *src)
为了保护源字符串，形参用const限定strSrc所指的内容，把const char *作为char *返回，类型不符，编译报错
/*
函数功能：复制字符串src 中的字符到字符串dest，包括空值结束符。
参数描述：
dest：目标字符串
src：源字符串
返回值：目标字符串的指针
*/
char *strcpy(char *dest,const char *src) // 实现src到dest的复制
{
if(NULL==dest || NULL==src) //判断参数src和dest的有效性
{
return NULL;
}
char *start=dest; //目标字符串首地址
while((*dest ++ = *src ++)!='\0'); //把src字符串的内容复制到dest下
return start;
}
char *mycpy(char *dest,char *src)
{
if(NULL==dest || NULL==src) //判断参数src和dest的有效性
{
return NULL;
}
char *p=dest;
while(*src != '\0')
{
*p=*src;
p++;
src++;
}
*p='\0';
return p;
}
2.void *memcpy(void *memTo,const void *memFrom,size_t size)
void *memcpy(void *str1 ,const void *str2 ,size_t size)
{if(str1 == NULL || str2 == NULL || n <= 0){
return NULL;
}
char *pstr1 = (char *)str1;
char *pstr2 = (char *)str2;
// 说明str1在str2中间，有内存重叠
// 为了防止copy时不破坏str2，从后向前拷贝
if(pstr1 > pstr2 && pstr1 < (pstr2 + n)){
pstr1 += (n - 1);
pstr2 += (n - 1);
while(n--){
*pstr1-- = *pstr2--;
}
}
else{
while(n--){
*pstr1++ = *pstr2++;
}
}
}strcpy和memcpy主要有以下3方面的区别。
1、复制的内容不同。strcpy只能复制字符串，而memcpy可以复制任意内容，例如字符数组、整型、结构体、类等。
2、复制的方法不同。strcpy不需要指定长度，它遇到被复制字符的串结束符"\0"才结束，所以容易溢出。memcpy则是根据其第3个参数决定复制的长度。
3、用途不同。通常在复制字符串时用strcpy，而需要复制其他类型数据时则一般用memcpy
3.char next_permutation(arr, arr+size)
/*
参数说明：arr：数组名 size：数组元素个数
函数功能： 返回值为bool类型，当当前序列不存在下一个排列时，函数返回false，否则返回true，排列好的数在数组中存储
注意：在使用前需要对欲排列数组按升序排序，否则只能找出该序列之后的全排列数。
比如，如果数组num初始化为2,3,1，那么输出就变为了：{2 3 1} {3 1 2} {3 2 1}
*/
我们可以将这个排列问题画成图形表示，即排列枚举树，比如下图为{1,2,3}的排列枚举树
算法思路：
(1)n个元素的全排列=（n-1个元素的全排列）+（另一个元素作为前缀）；
(2)出口：如果只有一个元素的全排列，则说明已经排完，则输出数组；
(3)不断将每个元素放作第一个元素，然后将这个元素作为前缀，并将其余元素继续全排列，等到出口，出口出去后还需要还原数组；
public class hello {
public static int arr[] = new int[]{1,2,3};
public static void main(String[] args) {
perm(arr,0,arr.length-1);
}
private static void swap(int i1, int i2) {
int temp = arr[i2];
arr[i2] = arr[i1];
arr[i1] = temp;
}
/**
* 对arr数组中的begin~end进行全排列
*
* 比如：
* arr = {1,2,3}
* 第一步：执行 perm({1,2,3},0,2),begin=0,end=2;
* j=0,因此执行perm({1,2,3},1,2),begin=1,end=2;
* j=1,swap(arr,0,0)-->arr={1,2,3}, perm({1,2,3},2,2),begin=2,end=2;
* 因为begin==end，因此输出数组{1,2,3}
* swap(arr,1,1) --> arr={1,2,3};
* j=2,swap(arr,1,2)-->arr={1,3,2}, perm({1,3,2},2,2),begin=2,end=2;
* 因为begin==end，因此输出数组{1,3,2}
* swap(arr,2,1) --> arr={1,2,3};
* j=1,swap(arr,0,1) --> arr={2,1,3}, perm({2,1,3},1,2),begin=1,end=2;
* j=1,swap(arr,1,1)-->arr={2,1,3} perm({2,1,3},2,2),begin=2,end=2;
* 因为begin==end，因此输出数组{2,1,3}
* swap(arr,1,1)--> arr={2,1,3};
* j=2,swap(arr,1,2)后 arr={2,3,1},并执行perm({2,3,1},2,2),begin=2,end=2;
* 因为begin==end，因此输出数组{2,3,1}
* swap(arr,2,1) --> arr={2,1,3};
* swap(arr,1,0) --> arr={1,2,3}
* j=2,swap(arr,2,0) --> arr={3,2,1},执行perm({3,2,1},1,2),begin=1,end=2;
* j=1,swap(arr,1,1) --> arr={3,2,1} , perm({3,2,1},2,2),begin=2,end=2;
* 因为begin==end，因此输出数组{3,2,1}
* swap(arr,1,1) --> arr={3,2,1};
* j=2,swap(arr,2,1) --> arr={3,1,2},并执行perm({2,3,1},2,2),begin=2,end=2;
* 因为begin==end，因此输出数组{3,1,2}
* swap(arr,2,1) --> arr={3,2,1};
* swap(arr,0,2) --> arr={1,2,3}
*
*/
public static void perm(int arr[], int begin,int end) {
if(end==begin){ //一到递归的出口就输出数组，此数组为全排列
for(int i=0;i<=end;i++){
System.out.print(arr[i]+" ");
}
System.out.println();
return;
}
else{
for(int j=begin;j<=end;j++){
swap(begin,j); //for循环将begin~end中的每个数放到begin位置中去
perm(arr,begin+1,end); //假设begin位置确定，那么对begin+1~end中的数继续递归
swap(begin,j); //换过去后再还原
}
}
}
}
全排列，由DFS（回溯）思想实现
#include<stdio.h>
int a[10],book[10],n;
void dfs(int step)
{
if(step==n+1)
{
for(int i=1;i<=n;i++)
printf("%3d",a[i]);
printf("\n");
return;
}
for(int i=1;i<=n;i++)
{
if(book[i]==0)
{
a[step]=i;
book[i]=1;
dfs(step+1);
book[i]=0; //将刚才尝试的扑克牌收回进行下一次尝试。
}
}
return;
}
int main()
{
scanf("%d",&n);
dfs(1);
return 0;
}
4.内存偏移量宏OFFSET的实现
写一个宏OFFSET，已知结构体中一个成员，求出该成员在结构体中的内存偏移量
#define OFFSET(type,member) ((size_t) & ((type *)0)->member)
1. ((type *)0) 将零转型为TYPE类型指针;
2. ((type *)0)->member 访问结构中的数据成员;3. &((type *)0)->member 取出数据成员的地址，即相对于0的偏移量，要的就这个;
4.((size_t) & ((type *)0)->member) 结果转换类型，size_t应该最终为unsigned int类型
测试程序：
#include <stdio.h>
#define OFFSET(type,member) ((size_t) & ((type *)0)->member)
struct _test_
{
char x;
int y;
float z;
};
int main()
{
int temp=-1;
temp=OFFSET(struct _test_,z);
printf("temp=%d\n",temp);
return 0;
}结果：
5.strcpy、strncpy与memcpy的区别与使用方法
1、memcpy函数
void *memcpy(void *s1, const void *s2, size_t n);
说明：
函数memcpy从s2指向的对象中复制n个字符到s1指向的对象中。如果复制发生在两个重叠的对象中，则这种行为未定义。
返回值：
函数memcpy返回s1的值。
2、strcpy函数
char *strcpy(char *s2, const char *s1);
说明：
函数strcpy把s1指向的串（包括空字符）复制到s2指向的数组中。如果复制发生在两个重叠的对象中，则这种行为未定义。
返回值：
函数strcpy返回s2的值。
3、strncpy函数
char *strncpy(char *s2, const char *s1, size_t n);
说明：
函数strncpy从s1指向的数组中最多复制n个字符（不复制空字符后面的字符）到s2指向的数组中。如果复制发生在两个重叠的对象中，则这种行为未定义。
如果s1指向的数组是一个比n短的字符串，则在s2定义的数组后面补空字符，直到写入了n个字符。
返回值：
函数strncpy返回s2的值。
strcpy 是依据 “\0” 作为结束判断的，如果 s2 的空间不够，则会引起 buffer overflow。
memcpy用来在内存中复制数据，由于字符串是以“\0”结尾的，所以对于在数据中包含“\0”的数据只能用memcpy，如:"hell\0oworld"。
strncpy和memcpy很相似，只不过它在一个终止的空字符处停止。当n>strlen(s1)时，给s2不够数的空间里填充“\0”；当n<=strlen(s1)时，s2是没有结束符“\0”的。
这里隐藏了一个事实，就是s2指向的内存一定会被写n个字符。
所以总的来说注意：
1、s2指向的空间要足够拷贝；使用strcpy时，s2指向的空间要大于等于s1指向的空间；使用strncpy或memcpy时，s2指向的空间要大于或等于n。
2、使用strncpy或memcpy时，n应该大于strlen(s1)，或者说最好n >= strlen(s1)+1；这个1 就是最后的“\0”。
3、使用strncpy时，确保s2的最后一个字符是“\0”。
672
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
