51.数组库内聚和耦合库中库

string.h

#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <locale.h>
#include <string.h>
#include <memory.h>


//stringA类型
struct stringA
{
    char *p;
    int memlength;//内存长度
};

//stringW类型
struct stringW
{
    wchar_t *p;
    int memlength;
};

//set_locale
void setbackground(const char *str);
//初始化,p分配是stringA类型还是stringW类型
int init(void *p, char ch);//ch = w ch = a自定义
//初始化数据
void initwithstring(void *p, char ch, void *pstr);
//显示数据
void show(void *p, char ch);

string.cpp

#include "string.h"

//初始化数据
int init(void *p, char ch)//ch = w ch = a自定义
{
    if (ch == 'w')
    {
         struct stringW *pw = (struct stringW *)p;//指针类型转换
         pw->p = NULL;//指向为空
         pw->memlength = 0;//长度为0
    }
    else if (ch == 'a')
    {
        struct stringA *pa = (struct stringA *)p;//指针类型转换
        pa->p = NULL;//指向为空
        pa->memlength = 0;//长度为0
    }
    else
    {
        abort();
    }
}

//用字符串初始化
void initwithstring(void *p, char ch, void *pstr)
{
    if (ch == 'w')
    {
         struct stringW *pw = (struct stringW *)p;//指针类型
         pw->p = NULL;
         pw->memlength = 0;

         wchar_t *pstrbak = (wchar_t *)pstr;//转换宽字符
         pw->p = (wchar_t *)malloc((wcslen(pstrbak) +1)* 2);
         pw->memlength = wcslen(pstrbak) + 2;
         wcscpy(pw->p, pstrbak);//拷贝
    }
    else if (ch == 'a')
    {
        struct stringA *pa = (struct  stringA *)p;
        pa->p = NULL;
        pa->memlength = 0;
                                                                               
        char *pstrbak = pstr;//转换窄字符
        pa->p = malloc(strlen(pstrbak) + 1);//分配内存,
        pa->memlength = strlen(pstrbak) + 1;//内存长度
        strcpy(pa->p, pstrbak);
    }
}

//显示
void show(void *p, char ch)
{
    
    if (ch == 'w')
    {
        struct stringW *pw = p;//指针类型转换,确定类型
        if (pw->p != NULL)
        {
            wprintf(L"%ls
", pw->p);
        }
    }
    else if (ch == 'a')
    {
        struct stringA *pa = p;//指针类型转换,确定类型
        if (pa->p != NULL)
        {
            printf("%s
", pa->p);
        }
    }
}

void setbackground(const char *str)
{
    setlocale(LC_ALL, str);
}

array.h

#include "string.h"

//字符串结构体
struct dataArray
{
    //void类型的指针,用的时候再进行类型转换
    void *p;
    //字符串数组长度
    int length;
    //数据类型 stringa stringw
    char datatype[10];
    //每一个元素的大小 sizeof(stringa) sizeof(stringw)
    int elemsize;
};

//初始化                            结构体            数组类型    数组每一个元素大小
void initWithNull(struct dataArray *pDataArray, char datatype[10], int elemsize);

//                                   结构体           数组类型      每一个元素大小      数组首地址    长度            
void initWithArray(struct dataArray *pDataArray, char datatype[10], int elemsize,    void *parray,    int n);

//在数组末尾添加一个元素
void backAddOne(struct dataArray *pdataarray, void *parray);//传递一个元素的地址

//显示数组
void showarray(struct dataarray *pdataarray, char datatype[10]);

array.cpp

#pragma once

#include "array.h"

//初始化
void initWithNull(struct dataArray *pDataArray, char datatype[10], int elemsize)
{
    //指针赋值为NULL
    pDataArray->p = NULL;
    //长度赋为0
    pDataArray->length = 0;
    //每一个元素的大小
    pDataArray->elemsize = elemsize;
    //把类型传给数组中的datatype
    strcpy(pDataArray->datatype, datatype);
}

//用一个array数组进行初始化
void initWithArray(struct dataArray *pDataArray, char datatype[10], int elemsize, void *parray, int n)
{
    //总指针赋值为NULL
    pDataArray->p = NULL;
    //数组长度赋为0
    pDataArray->length = 0;
    //每一个元素的大小
    pDataArray->elemsize = elemsize;
    //把类型传给数组中的datatype
    strcpy(pDataArray->datatype, datatype);

    //如果是"stringa"类型
    if (strcmp(pDataArray->datatype, "stringa") == 0)
    {
        //指针类型转换
        struct stringA *pa = parray;
        //每一个元素的大小
        pDataArray->elemsize = sizeof(struct stringA);
        //分配内存
        pDataArray->p = malloc(sizeof(struct stringA)*n);
        //内存拷贝,把所有结构体拷贝过去
        memcpy(pDataArray->p, parray, sizeof(struct stringA)*n);
        //长度为n
        pDataArray->length = n;
    }
}

//在数组尾部添加一个元素
void backAddOne(struct dataArray *pdataarray, void *parray)
{
    //如果是"stringa"类型
    if (strcmp(pdataarray->datatype, "stringa") == 0)
    {
        pdataarray->p = realloc(pdataarray->p, sizeof(struct stringA)*(pdataarray->length + 1));//拓展数据长度
        //接受首地址
        struct stringA *pa = pdataarray->p;
        struct stringA *palast = parray;//转换类型

        pa[pdataarray->length].p = palast->p;
        pa[pdataarray->length].memlength = palast->memlength;

        pdataarray->length += 1;
    }
}

//显示数据
void showarray(struct dataArray *pdataarray, char datatype[10])
{
    //如果是"stringa"类型
    if (strcmp(pdataarray->datatype, "stringa") == 0)
    {
        //转换数据类型
        struct stringA *pa = pdataarray->p;
        //依次循环,输出数据
        for (int i = 0; i < pdataarray->length; i++)
        {
            printf("%s  ", pa[i].p);//打印字符串
        }
        printf("
");
    }
}

main.c

#include "string.h"
#include "array.h"

void main()
{
    //setbackground("zh-CN");
    //struct stringA stringa1;
    //struct stringW stringw1;
    ////init(&stringa1, 'a');
    //initwithstring(&stringa1, 'a', "calc");
    //initwithstring(&stringw1, 'w', L"notepad78你好");
    //show(&stringa1, 'a');
    //show(&stringw1, 'w');

    struct stringA stringa[6];
    char *str[6] = { "calc","notepad","pause","12345","test" ,"hello"};
    
    for (int i = 0; i < 6; i++)
    {
        initwithstring(&stringa[i], 'a', str[i]);
    }

    struct dataArray data;
    initWithArray(&data, "stringa", sizeof(struct stringA), stringa, 5);
    showarray(&data, "stringa");

    //尾部插入
    backAddOne(&data, &stringa[2]);
    showarray(&data, "stringa");


    system("pause");
}

运行截图:

 总结:数组库有一个void类型的指针,可以指向很多数组,并控制数组.数组传递的是void类型,根据后面的参数进行转换,并分配内存.