7.29 二维数组 malloc 外挂实现库函数

首页 > 代码库 > 7.29 二维数组 malloc 外挂实现库函数

7.29 二维数组 malloc 外挂实现库函数

2024-07-20 19:09:25 220人阅读

数组与指针：

数组在传递参数里，作用一样： array 都是一个指针，接收数组的首地址

（int array[]，int n ）

( int * array, int n )

指针和数组可以等价转换

array[i] ========= *(array+i)

二维数组传参：

(int a[][], int R , int C) //错误

横坐标可以不写，列坐标必须要写。

(int a[][6], int R , int C)

#include <stdio.h>
#include <string.h>
void init(int a[][6] ,int m, int n)
{
        printf("%d\n",(int)sizeof(a)); //结果是4
}
int main()
{
        int a[5][6];
        init(a,5,6);
}

不同的指针+1的区别

int a [6] [4]

&a[0][0] + 1 // +了 4个字节

a[0] + 1 // +了 4个字节 a[0] 就从二维数组的概念转变成一维数组了

a +1 // +了 4*4个字节 a 应该从二维数组的角度

&a + 1 // +了 4*6*4个字节

0 0 0 0

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

随机输出扑克牌（不重复）：

#include <stdio.h>
#include <time.h>
#include <stdlib.h>
#define M 4
#define N 13
int main()
{
        char a[M][N] = {0};
        srand(time(NULL));
        int n,m,num;
        const char X[] = {‘1‘,‘2‘,‘3‘,‘4‘,‘5‘,‘6‘,‘7‘,‘8‘,‘9‘,‘t‘,‘j‘,‘q‘,‘k‘};
        const char Y[] = {‘a‘,‘b‘,‘c‘,‘d‘};
        printf("请输入你现在还有几张牌：");
        scanf("%d",&num);
        while(num>0)
        {
                m = rand()%4;
                n = rand()%13;
                if(!a[m][n])
                {
                        a[m][n] = 1;
                        num--;
                        printf("%c %c\n",Y[m],X[n]);
                }
        }
        return 0;
}

malloc的使用 :

#include <stdio.h>
#include <stdlib.h>
int main()
{
        int n;
        printf("你的名字最多多长:");
        scanf("%d", &n);
        getchar(); //过滤回车
        char * a;
        a = (char *)malloc(n * sizeof(char));
        printf("请输入你的名字:");
        gets(a);
        printf("%s\n", a);
        free(a);
}

realloc的使用 :

realloc( 指针，容量 ); //容量是改变后的大小，不是增加的大小

p = realloc( p , 100) //返回的地址，是现在100个的首地址，不是新增加的首地址

dll函数外挂 :

_declspec(dllexport) void waigua()

{

}

_declspec(dllexport)是导出一个函数

交换字符串：

#include <stdio.h>
#include <string.h>
char * str_reverse(char * str)
{
        char temp;
        int len = strlen(str),i;
        for (i = 0; i < len/2; i++)
        {
                temp = str[i];
                str[i] = str[len-i-1];
                str[len-i-1] = temp;
        }
        return str;
}
int main()
{
        char s[100] = "hello";
        char * p = str_reverse(s);
        printf("%s\n",p);
}

字符串某个字符出现的次数：

#include <stdio.h>
#include <string.h>
int str_times(char * str,char ch)
{
        int i = 0;
        while(*str != ‘\0‘)
        {
                if (*str == ch)
                        i++;
                str++;
        }
        return i;
}
int main()
{
        char s[100] = "hello";
        printf("%d\n",str_times( s , ‘l‘));
}

strlen的实现 :

第一种实现方案：

sizt_t strlen(const char *s)
{
    size_t n = 0;
    while(*s++)
            n++;
    return n;
}

第二种实现方案：

sizt_t strlen(const char *s)
{
    const char * p = s;
    while(*s)
           s++
    return s - p;
}

自己写一个strlen 类似 mb_strlen 汉字只算一个字符

#include <stdio.h>
#include <string.h>
int mb_strlen(const char * p)
{
    int len = 0;
    while( *p )
    {
        len++;
        if(*p++ < 0)
            p++;
    }
    return len;
}
int main()
{
    char *s = "a我b是c你d大e";
    int len = mb_strlen( s );
    printf("%d\n",len);
    return 0;
}

strstr的实现：

#include <stdio.h>
#include <string.h>
char * str_find(char * str, char * f)
{
        while (*str)
        {
                char * a = str;
                char * b = f;
                char * res = NULL;
                if (*a == *b)
                {
                        res = a;
                        while (*++a == *++b ) ;
                        if (*b == ‘\0‘)
                                return res;
                }
                str++;
        }
        return NULL;
}
int main()
{
        char *s = "helloworld";
        printf("%s\n",str_find(s ,"lo"));
        return 0;
}

strcpy的实现：

#include <stdio.h>
#include <string.h>
void str_cpy( char * dest , const char * src)
{
    while(*dest++ = *src++);
}
int main()
{
    char buf[100] = "aaaaaaaaaaaaaaaaaaaaaaaa";;
    str_cpy(buf , "liuwei");
    printf("%s\n" , buf);
    return 0;
}

strcat的实现：

#include <stdio.h>
#include <string.h>
char * str_cat(char *p,char *s)
{
        char * bak = p;
        while(*p)
        {
                p++;
        }
        while(*p++ = *s++)
        {
        }
        return bak;
}
int main()
{
        char s[10] = "hello";
        char v[10] = "world";
        printf("%s\n",str_cat(s,v));
        return 0;
}

strtok的实现（不完善）：

#include <stdio.h>
#include <string.h>
char *str_tok(char * str, const char * de)
{
        static char * n;
        char * r;                    //返回的首地址
        const char * de_bak = de;    //分隔符地址备份
        if (str != NULL)
                n = str;
        r = n;
        while (*n)
        {
                while (*de)
                {
                        if (*n == *de)
                        {
                                *n++ = ‘\0‘;
                                return r;
                        }
                        de++;
                }
                de = de_bak;
                n++;
        }
        if (r == n)
        {
                return NULL;
        }
        return r;
}
int main()
{
        char s[] = "abcd,cdef,efgh,ghjk";
        char *de = ",c";
        printf("%s\n", str_tok(s, de));
        char *p;
        while (p = str_tok(NULL, de))
                printf("%s\n", p);
        return 0;
}

来自为知笔记(Wiz)

7.29 二维数组 malloc 外挂实现库函数

声明：以上内容来自用户投稿及互联网公开渠道收集整理发布，本网站不拥有所有权，未作人工编辑处理，也不承担相关法律责任，若内容有误或涉及侵权可进行投诉：投诉/举报工作人员会在5个工作日内联系你，一经查实，本站将立刻删除涉嫌侵权内容。

联系
我们

首页 > 代码库 > 7.29 二维数组 malloc 外挂 实现库函数

7.29 二维数组 malloc 外挂 实现库函数

看完仍有疑问？有类似问题直接问程序猿

首页 > 代码库 > 7.29 二维数组 malloc 外挂实现库函数

7.29 二维数组 malloc 外挂实现库函数