字符数组拆分

执行结果

/*
* @Author: wujianfei
* @Date:   2018-04-10 21:09:59
* @Last Modified by:   wujianfei
* @Last Modified time: 2018-04-12 21:08:57
*/
#include <stdio.h>
#include <stdlib.h>

typedef struct {
    int dime_1_count;
}KeyVal;

char** DimeRoom = NULL;
int dime_2_count_store_[100];

KeyVal getKeyValueCharArray(const char *chars,const int len,char splitChar){

    //========计算第一维度的长度dime_1_count+1==========================================
     int dime_1_count = 0;//存储键值对type=value的数量用于创建二维数组的第一维度
    int dime_2_count = 80;//定义第二维度存储的字符数组长度(type=value拆成数组的长度)
    int index0 = 0;
    while(index0<len){
        if(chars[index0] == splitChar){
            dime_1_count++;
        }
        index0++;
    }
    dime_1_count++;
    //==========计算第二维度的长度=======================================
    int dime_2_count_store[dime_1_count];//存储每个二维的长度
    int index1 = 0;//标记chars
    int tempLengthStore = 0;//临时存储，存储每次计算的第二维度的长度
    int current_dime_1 = 0;//存放当前所在的维度
    int lastIndex0 = 0;//最后一个逗号的位置
    while(index1<len){
        if(chars[index1] == splitChar){
            dime_2_count_store[current_dime_1] = tempLengthStore;//把第二维度的长度存储到第一维度中
            printf("> %d 
",index1);
            tempLengthStore = 0;//初始化当前维度
            current_dime_1++;//计算下一个维度
            lastIndex0 = index1;//标记最后一个逗号的位置
        }else{
            tempLengthStore++;
        }
        index1++;
    }
    //最后一段长度
    tempLengthStore = 0;
    lastIndex0++;
    while(lastIndex0<len){
        tempLengthStore++;
        lastIndex0++;
    }
    dime_2_count_store[dime_1_count-1] = tempLengthStore;
    //==========往store中存储字符==================================================================
    int dimeIndex_1 = 0;//一维
    int dimeIndex_2 = 0;//二维
    int lastIndex1 = 0; //最后一次出现逗号的位置
    char tempStore[80];//存key=value的临时数组
    int tempStoreIndex = 0;//临时存储游标
    int index3 = 0;
    while(index3<sizeof(tempStore)){
        tempStore[index3] = 0;
        index3++;
    }
    char store[dime_1_count][80];//用二维来存储键值
    //将store上的所有位清0
    int storeClearIndex = 0;
    while(storeClearIndex<dime_1_count){
        int storeClearIndex_2dime = 0;
        while(storeClearIndex_2dime<80){
            store[storeClearIndex][storeClearIndex_2dime] = 0;
            storeClearIndex_2dime++;
        }
        storeClearIndex++;
    }

    int storeCurrentRow = 0;//用来标记存储到第几行了
    int index2 = 0; //用来循环遍历的
    while(index2<len){
        if(chars[index2] == splitChar){
            dimeIndex_1++;//一维移位
            lastIndex1 = index2;//记录最后出现逗号的位置
            int index87 = 0;
            while(index87<sizeof(tempStore)){
                store[storeCurrentRow][index87] = tempStore[index87];
                index87++;
            }
            storeCurrentRow++;
            int thisTemp = 0;
            while(thisTemp<sizeof(tempStore)){
                tempStore[thisTemp] = 0;
                thisTemp++;
            }
            tempStoreIndex = 0;
        }else{
            tempStore[tempStoreIndex] = chars[index2];
            tempStoreIndex++;
            dimeIndex_2++;//二维移位
        }
        index2++;
    }

    //清理最后一行上的每个位
    int index4 = 0;
    while(index4<80){
        store[storeCurrentRow][index4] = 0;
        index4++;
    }
    //存储最后一行
    int index5 = 0;
    while(index5<sizeof(tempStore)){
        store[storeCurrentRow][index5] = tempStore[index5];
        index5++;
    }
    // printf("> %s %s %s %s 
",store[0],store[1],store[2],store[3]);
    //创建二级指针，用于存放二维数组，这里创建dime_1_count行
    DimeRoom = (char *)malloc(sizeof(char *)*dime_1_count);
    //将二维数组转为二级指针
    int index6 = 0;
    while(index6<dime_1_count){
        DimeRoom[index6] = store[index6];
        index6++;
    }
    //=========测试================================================================
    // int index77 = 0;
    // while(index77<dime_1_count){
    //     printf("%d 
",dime_2_count_store[index77]);
    //     index77++;
    // }

    // int index79 = 0;
    // while(index79<dime_1_count){
    //     printf(">>>>>>>>>>%s 
",*(dime+index79));
    //     index79++;
    // }
    // printf("===================fuction is over====================================
");
    KeyVal keyV;
    keyV.dime_1_count = dime_1_count;
    int index7 = 0;
    while(index7<dime_1_count){
        printf("====>%d 
",dime_2_count_store[index7]);
        dime_2_count_store_[index7] = dime_2_count_store[index7];
        index7++;
    }
    return keyV;
}


int main () {
    printf("starting...
");
    char chars[100] = {'t','y','p','e','=','v','a','l','u','e',',',
                  't','y','p','e','2','=','v','a','l','u','e','2',',',
                    't','y','p','e','3','=','v','a','l','u','e','3',',','t'};
    KeyVal keyV = getKeyValueCharArray(chars,38,',');
    printf("keyV.dime_1_count = %d 
",keyV.dime_1_count );

    int i = 0;
    while(i<keyV.dime_1_count){
        printf("main>>>>>>>>%s 
",*(DimeRoom+i));
        i++;
    }

    int i2 = 0;
    while(i2<keyV.dime_1_count){
        printf("dime_2_count_store_>>>>>>>>%d 
",dime_2_count_store_[i2]);
        i2++;
    }

    free(DimeRoom);
    return 0;
}

 执行结果：

。