C语言进阶21收尾(编程作业)(atoi，strncpy,strncat,offsetof模拟实现+找单身狗+宏交换二进制奇偶位）

1 atoi函数的模拟实现

1.1 atoi的使用

int atoi (const char* string);

atoi：把字符串nptr转换为int。

atoi函数使用实例：

#include 
#include 
int main()
{
    char arr[100] = "12345";
    int ret = atoi(arr);
    printf("%d\n", ret);
    return 0;
}

1.2 初步模拟实现

初步模拟实现可以把数字字符串转换为整数，由于没有考虑正负号，所以只能转换为正数；

还有很多特殊情况没有考虑，这里先来看看初步的模拟实现；

#include 
#include 
int my_atoi(const char* str)
{
    int n = 0;
    while (*str != '\0')
    {
        n = n * 10 + (*str - '0');
        str++;
    }
    return n;
}
int main()
{
    char arr[10] = "12345";
    //int ret = atoi(arr);
    int ret = my_atoi(arr);
    printf("%d\n", ret);
    return 0;
}

1.3 atoi函数的具体实现（考虑6种特殊情况）

面试时写上面的那就真是面逝了，下面我们来考虑6种特殊的情况

1.空指针
2.空字符串
3.字符串中的空格
4.非数字字符
5.溢出问题（所得数字大于INT_MAX或者小于INT_MIN）
6.正负号问题

1.空指针的问题很容易解决：使用assert函数断言即可；

2.空字符串的第一个元素即为'\0'，在前面判断是否为'\0'返回就可以了，

但是有一个问题，返回的0时原字符是'0还是空字符串，这里存在非法转换和合法转换，

可以使用枚举解决，创建一个枚举类型初始化为非法，因为非法的情况比较多，合法的情况就一种。

初始化为非法有利于问题的解决，空字符串转换为整数0是一种非法转换。

3.当遇到字符串中有空格的时候，可以直接跳过空格所在的内容，指针++指向下一个字符。

4.非数字字符，例如"123a456",这里在指针走到a的时候，直接返回123就行了，

不需要继续往下走了，此时是一种非法转换。

5.溢出问题是数字字符的一种情况，当所得的n的值大于最大整型或者小于最小整型的时候，

返回最大整型或者最小整型，溢出问题是一种非法转换。

6.正负号的问题可以找一个变量flag来记录，初始化为1，当是正数的时候flag的值不变为1；

若字符串中有'-',flag的值变为-1，记录符号位。

代码实现：

#include 
#include 
#include 
#include //isspace isdigit
#include //INT_MAX  INT_MIN
enum State
{
    INVALID,
        VALID
}state=INVALID;//初始化为invalid 非法的，无效的
int my_atoi(const char* str)
{
    assert(str != NULL);//空指针
    if (*str == '\0')//空字符串
    {
        return 0;
    }
    while (isspace(*str))//字符串中的空格
    {
        str++;
    }
    int flag = 1;
    if (*str == '-') //正负号问题
    {
        flag = -1;
        str++;
    }
    if (*str == '+')
    {
        flag = 1;
        str++;
    }
    long long n = 0;
    while (*str != '\0')
    {
        if (isdigit(*str))//数字字符
        {
            n = n * 10 + (*str - '0');
            if (n > INT_MAX || n < INT_MIN)//5.溢出问题
            {
                break;
            }
        }
        else//不是数字字符直接跳出循环，state此时还是INVALID
        {
            break;
        }
        str++;
    }
    if (*str == '\0')
    {
        state = VALID;
    }
    return (int)(n*flag);
}
int main()
{
    char arr[50] = "   -123";
    //int n = atoi(arr);
    int n = my_atoi(arr);
    //判断合法非法转换
    if (state == VALID)
    {
        printf("合法转化：n = %d\n", n);
    }
    else
    {
        printf("非法转换：n = %d\n", n);
    }
    return 0;
}

2 strncpy函数的模拟实现

strncpy还有下面的strncat和其它字符串函数我们在之前字符串的篇章讲过。

C语言进阶⑬(字符串)(指针编程作业)(模拟实现字符串函数)_GR C的博客-CSDN博客

char * strncpy ( char * destination, const char * source, size_t num );

Copies the first num characters of source to destination. If the end of the source C string

(which is signaled by a null-character) is found before num characters have been copied,

destination is padded with zeros until a total of num characters have been written to it.

从源字符串拷贝num个字符到目标空间。

如果源字符串的长度小于num，则拷贝完源字符串之后，在目标的后边追加0，直到num个。

#include
#include
#include
char* my_strcpy(char* dest, const char* src, int n)
{
    assert(dest != NULL);
    assert(src != NULL);
    char* ret = dest;//先让ret指向dest的起始地址
    int i = 0;
    for (i = 0; i < n && src[i]; i++)
    {
        dest[i] = src[i];
    }
    if (i < n)
    {
        dest[i] = '\0';
    }
    return ret;
}
int main()
{
    char arr1[30] = "##########################";
    char arr2[] = "hello world";
    //printf("%s\n", strncpy(arr1, arr2,5));
    printf("%s\n", my_strcpy(arr1, arr2, 5));
    return 0;
}

3 strncat函数的模拟实现

char * strncat ( char * destination, const char * source, size_t num );

追加 num个字符到目标空间

Appends the first num characters of source to destination, plus a terminating null character.

If the length of the C string in source is less than num, only the content up to the terminating null-character is copied

注意事项：如果源字符串的长度小于 num，则只复制 \0 之前的内容。

#include
#include
#include
char* my_strncat(char* dest, const char* src,int n)
{
    assert(dest != NULL);
    assert(src != NULL);
    char* ret = dest;//让ret指向dest的起始地址
    while (*dest)//找到'\0'  '\0'的ASCII码为0跳出循环
    {
        dest++;
    }
    int i = 0;
    for (i = 0;i < n && src[i];i++)
    {
        dest[i] = src[i];
    }
    if (i < n)
    {
        dest[i] = '\0';
    }
    return ret;
}
int main()
{
    char arr1[20] = "hello ";
    char arr2[] = "world";
    //printf("%s\n", strncat(arr1, arr2,3));
    printf("%s\n", my_strncat(arr1, arr2,3));
    return 0;
}

4 找一个单身狗

【题目内容】

一个数组中只有一个数字是出现一次，其他所有数字都出现了两次。

编写一个函数找出这两个只出现一次的数字。

解析：

例如数组 1 2 2 3 3 4 1中 4就是单身狗

思路 因为单身狗只有一个 直接全部异或

异或的特点相同为0，相异为1，

如果有重复的数字 异或就等于0 最后只会留一下一个单身狗

看代码：

#include
#include
int find_dog(int arr[],int sz)
{
    int dog = 0;
    for (int i = 0;i < sz;i++)
    {
        dog ^= arr[i];
    }
    return dog;
}
int main()
{
    int arr[] = { 1,2,2,3,3,4,1 };
    int sz = sizeof(arr) / sizeof(arr[0]);
    printf("单身狗是%d", find_dog(arr,sz));
    return 0;
}

5 找两个单身狗

【题目内容】

一个数组中只有两个数字是出现一次，其他所有数字都出现了两次。

编写一个函数找出这两个只出现一次的数字。

解析：

如果我们按照之前的思路直接异或 肯定只会出来一个四不像数

假设数组1 2 3 3 1 4

我们把 两个单身狗分成两个组

而组中其他的数字就都不是单身狗

此时我们在分组异或就分别得到了2个单身狗

问题 我们以什么为依据分组？

依据 二进制位 异或把相同的数字变成0，不同的数字变成1，

我们根据1在哪位 就说明单身狗这个的二进制位不同 ，按照这个二进制位分

两个单身狗是不可能进到一组的

① 我们依然把数组中所有数字异或到一起 然后判断这个数字的二进制位 因为有两个单身狗2和4

0010 和0100最后异或完毕得到的二进制位是 0110 说明两个单身狗数字的二进制最后位是相等

我们左移一位得到了1 就说明 两个单身狗数字的倒数第二位二进制数 不相等

② 让数组中所有的数字左移一位 如果等于 1 放进第一个数组中

如果等于0 放进第二个数组中

③ 把数组中的数字全部异或就得到了 2个单身狗

代码：

#include
void find_two_dog(int arr[],int sz,int* px,int* py)
{
    int sum = 0;
    for (int i = 0; i < sz; i++)
    {
        sum ^= arr[i];
    }
    int count = 0;
    for (int i = 0; i < 32; i++)
    {
        if (sum & 1 << i) //循环判断第几位是1
        {
            count = i;//如果是1 记录下来
            break;
        }
    }
    int dog1 = 0, dog2 = 0;
    for (int i = 0; i < sz; i++)
    {
        if (arr[i] & 1 << count)
        {
            dog1 ^= arr[i];
        }
        else
        {
            dog2 ^= arr[i];
        }
    }
    *px = dog1;
    *py = dog2;
}
int main()
{
    int arr[] = { 1,2,3,3,1,4 };
    int sz = sizeof(arr) / sizeof(arr[0]);
    int x = 0, y = 0;//因为不能return两个值，所以设置两个返回型参数
    find_two_dog(arr, sz, &x, &y);
    printf("第一个单身狗%d\n第二个单身狗%d",x, y);
    return 0;
}

6 宏交换二进制奇偶位

【题目内容】

写一个宏，可以将一个整数的二进制位的奇数位和偶数位交换。

解题思路：

做交换，就直接将二进制位中奇数和偶数部分分别全部提取出来，交换一下位置，

再重新以相加或者位运算或的方式求和，即可得到想要的结果。

首先要做的是：分别提取给出整数的奇数位和偶数位，即：

按从右往左数第一位是1（奇数）

提取奇数位：(N) & 01010101010101010101010101010101 (0x55555555)

提取偶数位：(N) & 10101010101010101010101010101010 (0xaaaaaaaa)

将奇数位左移一位，偶数位右移一位。

相加移位后结果（或者位运算或）。

#include      //a  1010                   5  0101
#define SWAP(R) (((R) & 0xaaaaaaaa)>>1) + (((R) & 0x55555555)<<1)
int main()
{
    int a = 10;
    printf("%d\n", SWAP(a));
    return 0;
}

7 offsetof宏的模拟实现

写一个宏，计算结构体中某变量相对于首地址的偏移，并给出说明

考察：offsetof宏的实现

offsetof介绍：

格式： offsetof(type, member)
头文件：
功能：返回成员 相对于结构或联合 起始地址的偏移量（以 字节为单位），返回类型是 size_t。

这个宏有两个参数：

type 是一个结构体类型或联合类型；
member 是结构体或联合的某一个成员；

使用代码：

#include 
#include 
struct S
{
    int a;//0 1 2 3
    char b;//4
    //5
    short c;//6  7
};
int main()
{
    printf("%d\n", offsetof(struct S, a));
    printf("%d\n", offsetof(struct S, b));
    printf("%d\n", offsetof(struct S, c));
    return 0;
}

模拟实现：

#include 
#include 
//结构体起始地址加上该成员相对于起始地址的偏移量就是成员变量的地址。
//想要知道成员相对于结构体起始地址的偏移量，假设结构体起始地址位于0地址处，
//那么结构体成员变量的地址强制类型转换为size_t后就相当于该成员相对于起始地址的偏移量
#define OFFSETOF(type, member) (size_t)(&(((type*)0)->member))//-0忽略了
struct S 
{
    int a;//0 1 2 3
    char b;//4
    //5
    short c;//6  7
};
int main() 
{
    printf("%d\n", offsetof(struct S, a));
    printf("%d\n", offsetof(struct S, b));
    printf("%d\n", offsetof(struct S, c));

    printf("%d\n", OFFSETOF(struct S, a));
    printf("%d\n", OFFSETOF(struct S, b));
    printf("%d\n", OFFSETOF(struct S, c));
    return 0;
}

C语言完结撒花

下个专栏是C语言实现初阶数据结构吧

（穿越回来贴个链接）③数据结构与算法（初阶）C语言描述_GR C的博客-CSDN博客