20160223.CCPP體系詳解(0033天)
程式片段(01):MyArray.h+MyArray.c+main.c
內容概要:陣列庫
///MyArray.h
#pragma once
#define DT int//型別通用
typedef struct
{
DT * pStart;//起始地址
int len;//元素個數
int sortState;//排序狀態(0無序+1有序)
}Array;
typedef struct
{
DT ** ppStart;
int len;
}ResArray;
void initArray(Array * pArray);
void initArrayWithData(Array * pArray, DT data);
void initArrayWithDatas(Array * pArray, DT * pDatas, int pDatasLen);
void showArray(Array * pArray);
void arrayAddData(Array * pArray, DT data);
void arrayAddDatas(Array * pArray, DT * pDatas, int pDatasLen);
DT * arrayFindFirstData(Array * pArray, DT data);
ResArray arrayFindAllDatas(Array * pArray, DT data);
void arrayInsertData(Array * pArray, DT data, DT insertData);
void arrayInsertDatas(Array * pArray, DT data, DT * pInsertDatas, int pInsertDatasLen);
void arrayDelFirstData(Array * pArray, DT data);
void arrayDelAllData(Array * pArray, DT data);
void arrayUpdateFirstData(Array * pArray, DT oldData, DT newData);
void arrayUpdateAllData(Array * pArray , DT oldData, DT newData);
//擴充套件功能:
// 1.排序:
// 冒泡(左右)-->選擇-->插入-->快速(單執行緒)-->希爾(多執行緒)-->堆排序
// 2.查詢:
// 二分-->插值
// 3.可變:
// 可變引數
// 4.多執行緒檢索
///MyArray.c
#include "MyArray.h"
#include <stdlib.h>
#include <memory.h>
#include <stdio.h>
void initArray(Array * pArray)
{
if (NULL == pArray)
{
printf("init error! \n");
abort();
}
pArray->pStart = NULL;
pArray->len = 0;
pArray->sortState = 0;
}
void initArrayWithData(Array * pArray, DT data)
{
if (NULL == pArray)
{
printf("init error! \n");
abort();
}
pArray->pStart = (DT *)malloc(sizeof(DT));
*(pArray->pStart) = data;
pArray->len = 1;
pArray->sortState = 0;
}
void initArrayWithDatas(Array * pArray, DT * pDatas, int pDatasLen)
{
if (NULL == pArray)
{
printf("init error! \n");
abort();
}
pArray->pStart = (DT *)malloc(pDatasLen * sizeof(DT));
memcpy(pArray->pStart, pDatas, pDatasLen * sizeof(DT));
pArray->len = pDatasLen;
pArray->sortState = 0;
}
void showArray(Array * pArray)
{
if (NULL == pArray || NULL == pArray->pStart || 0 == pArray->len)
{
printf("沒有資料咋列印? \n");
abort();
}
printf("陣列此時狀態: \n");
for (int i = 0; i < pArray->len; ++i)
{//優先順序問題:從第一個識別符號開始進行判斷(從左往右不斷結合)
printf("%4d", pArray->pStart[i]);
}
}
void arrayAddData(Array * pArray, DT data)
{
if (NULL == pArray)
{
printf("陣列根本不存在! \n");
abort();
}
if (NULL == pArray->pStart)
{
initArrayWithData(pArray, data);
}
else
{
pArray->pStart = (DT *)realloc(pArray->pStart, (pArray->len + 1) * sizeof(DT));
pArray->pStart[pArray->len] = data;
++pArray->len;
}
}
void arrayAddDatas(Array * pArray, DT * pDatas, int pDatasLen)
{
if (NULL == pArray)
{
printf("陣列根本不存在! \n");
abort();
}
if (NULL == pArray->pStart)
{
initArrayWithDatas(pArray, pDatas, pDatasLen);
}
else
{
pArray->pStart = (DT *)realloc(pArray->pStart, (pArray->len + pDatasLen) * sizeof(DT));
memcpy(pArray->pStart + pArray->len, pDatas, pDatasLen * sizeof(DT));
pArray->len += pDatasLen;
}
}
DT * arrayFindFirstData(Array * pArray, DT data)
{
if (NULL == pArray)
{
printf("陣列根本不存在! \n");
abort();
}
if (NULL == pArray->pStart)
{
printf("陣列未初始化資料! \n");
abort();
}
if (0 == pArray->len)
{
printf("陣列沒有資料! \n");
abort();
}
for (int i = 0; i < pArray->len; ++i)
{
if (data == *(pArray->pStart + i))
{
return pArray->pStart + i;
}
}
return NULL;
}
ResArray arrayFindAllDatas(Array * pArray, DT data)
{
if (NULL == pArray)
{
printf("陣列根本不存在! \n");
abort();
}
if (NULL == pArray->pStart)
{
printf("陣列未初始化資料! \n");
abort();
}
ResArray resArray;
resArray.len = 0;
for (int i = 0; i < pArray->len; ++i)
{
if (data == pArray->pStart[i])
{
++resArray.len;
}
}
resArray.ppStart = (DT **)malloc(resArray.len * sizeof(DT *));
int j = 0;
for (int i = 0; i < pArray->len; ++i)
{
if (data == pArray->pStart[i])
{
resArray.ppStart[j++] = pArray->pStart + i;
}
}
return resArray;
}
void arrayInsertData(Array * pArray, DT data, DT insertData)
{
if (NULL == pArray)
{
printf("陣列根本不存在! \n");
abort();
}
if (NULL == pArray->pStart)
{
printf("陣列沒有初始化資料! \n");
abort();
}
if (0 == pArray->len)
{
printf("陣列沒有資料! \n");
abort();
}
DT * pFindData = arrayFindFirstData(pArray, data);
if (NULL == pFindData)
{
printf("未能找到資料待插入的位置! \n");
abort();
}
int relPos = pFindData - pArray->pStart;
pArray->pStart = (DT *)realloc(pArray->pStart, (pArray->len + 1) * sizeof(DT));
for (int i = pArray->len; i >= relPos; --i)
{
*(pArray->pStart + i + 1) = *(pArray->pStart + i);
}
*(pArray->pStart + relPos) = insertData;
++pArray->len;
}
void arrayInsertDatas(Array * pArray, DT data, DT * pInsertDatas, int pInsertDatasLen)
{
if (NULL == pArray)
{
printf("陣列根本不存在! \n");
abort();
}
if (NULL == pArray->pStart)
{
printf("陣列未初始化資料! \n");
abort();
}
if (0 == pArray->len)
{
printf("陣列沒有資料! \n");
abort();
}
DT * pFindData = arrayFindFirstData(pArray, data);
if (NULL == pFindData)
{
printf("未能找到資料待插入的位置! \n");
abort();
}
int relPos = pFindData - pArray->pStart;
pArray->pStart = (DT *)realloc(pArray->pStart, (pArray->len + pInsertDatasLen) * sizeof(DT));
for (int i = pArray->len; i >= relPos; --i)
{
*(pArray->pStart + i + pInsertDatasLen) = *(pArray->pStart + i);
}
memcpy(pArray->pStart + relPos, pInsertDatas, pInsertDatasLen * sizeof(DT));
pArray->len += pInsertDatasLen;
}
void arrayDelFirstData(Array * pArray, DT data)
{
if (NULL == pArray)
{
printf("陣列不存在! \n");
abort();
}
if (NULL == pArray->pStart)
{
printf("陣列無初始化資料! \n");
abort();
}
if (0 == pArray->len)
{
printf("陣列沒有資料! \n");
abort();
}
DT * pFindData = arrayFindFirstData(pArray, data);
if (NULL == pFindData)
{
printf("沒有找到待刪除資料! \n");
abort();
}
int relPos = pFindData - pArray->pStart;
for (int i = relPos; i < pArray->len - 1; ++i)
{
*(pArray->pStart + i) = *(pArray->pStart + i + 1);
}
--pArray->len;
pArray->pStart = (DT *)realloc(pArray->pStart, pArray->len * sizeof(DT));
}
void arrayDelAllData(Array * pArray, DT data)
{
if (NULL == pArray)
{
printf("陣列不存在! \n");
abort();
}
if (NULL == pArray->pStart)
{
printf("陣列無初始化資料! \n");
abort();
}
if (0 == pArray->len)
{
printf("陣列沒有資料! \n");
abort();
}
for (DT * p = arrayFindFirstData(pArray, data); NULL != p; p = arrayFindFirstData(pArray, data))
{
arrayDelFirstData(pArray, data);
}
}
void arrayUpdateFirstData(Array * pArray, DT oldData, DT newData)
{
if (NULL == pArray)
{
printf("陣列不存在! \n");
abort();
}
if (NULL == pArray->pStart)
{
printf("陣列未初始化資料! \n");
abort();
}
if (0 == pArray->len)
{
printf("陣列沒有資料! \n");
abort();
}
DT * pFindData = arrayFindFirstData(pArray, oldData);
if (NULL == pFindData)
{
printf("未能找到待替換的資料! \n");
abort();
}
*pFindData = newData;
}
void arrayUpdateAllData(Array * pArray, DT oldData, DT newData)
{
if (NULL == pArray)
{
printf("陣列不存在! \n");
abort();
}
if (NULL == pArray->pStart)
{
printf("陣列未初始化資料! \n");
abort();
}
if (0 == pArray->len)
{
printf("陣列沒有資料! \n");
abort();
}
for (DT * p = arrayFindFirstData(pArray, oldData); NULL != p; p = arrayFindFirstData(pArray, oldData))
{
arrayUpdateFirstData(pArray, oldData, newData);
}
}
///main.c
#include "MyArray.h"
#include <stdlib.h>
int main(void)
{
Array array;
//initArrayWithData(&array, 1);
int intArr1[5] = { 1, 2, 3, 4, 5 };
initArrayWithDatas(&array, intArr1, 5);
//arrayAddData(&array, 6);
int intArr2[3] = { 6, 7, 8 };
arrayAddDatas(&array, intArr2, 3);
//arrayInsertData(&array, 6, 7);
int intArr3[3] = { 8, 9, 10 };
arrayInsertDatas(&array, 6, intArr3, 3);
//arrayDelFirstData(&array, 6);
//arrayDelAllData(&array, 8);
//arrayUpdateFirstData(&array, 8, 11);
arrayUpdateAllData(&array, 8 ,11);
showArray(&array);
system("pause");
}
//void main()
//{
// struct array mydata;
// int a[10] = { 1, 2, 6, 4, 5, 6, 7, 8, 9, 6 };
// int b[5] = { 11, 12, 13, 14 };
// int c[4] = { 21, 22, 23, 24 };
// initwitharray(&mydata, a, 10);
// show(&mydata);
//
// //changeallobject(&mydata, 6, 660);
// //changefirstobject(&mydata,5, 950);
// //insertobjects(&mydata, 8, c, 4);
// //deleteallobject(&mydata, 6);
// //deletefirstobject(&mydata, 6);
// //addobjects(&mydata, b, 5);
// //addobjects(&mydata, c, 4);
// //insertobject(&mydata, 1,999);//根據位置插入
// struct Res res = findall(&mydata, 6);
// for (int i = 0; i < res.n;i++)
// {
// printf("\n%p,%d", res.ppstart[i], *res.ppstart[i]);
// }
//
// show(&mydata);
//
//
//
//
//
//
// system("pause");
//}
程式片段(02):MyArray.h+MyArray.c+main.c
內容概要:陣列庫
///MyArray.h
#pragma once
//#define DT int
#define DT char *
typedef struct
{
DT * pStart;
int len;
int sortState;
}Array;
typedef struct
{
DT ** ppStart;
int len;
}ResArray;
typedef int (* EqualFunP)(DT *, DT *);
typedef void(*PrintFunP)(Array * pArray);
void initArray(Array * pArray);
void initArrayWithData(Array * pArray, DT data);
void initArrayWithDatas(Array * pArray, DT * pDatas, int pDataLen);
int isValidA(Array * pArray);
int isValidB(Array * pArray);
int isValidC(Array * pArray);
int isValidD(Array * pArray);
int isValidE(Array * pArray);
void printInt(Array * pArray);
void printString(Array * pArray);
void showArray(Array * pArray, PrintFunP funP);
void arrayAddData(Array * pArray, DT data);
void arrayAddDatas(Array * pArray, DT * pDatas, int pDatasLen);
int intIsEqual(int * pDataA, int * pDataB);
int strIsEqual(char ** pDataA, char ** pDataB);
DT * arraySelectFirstData(EqualFunP funP, Array * pArray, DT data);
ResArray arraySelectAllDatas(EqualFunP funP, Array * pArray, DT data);
void arrayInsertData(Array * pArray, DT data, DT insertData);
void arrayInsertDatas(Array * pArray, DT data, DT * pInsertDatas, int pInsertDatasLen);
void arrayDeleteFirstData(Array * pArray, DT data);
void arrayDeleteAllDatas(Array * pArray, DT data);
void arrayUpdateFirstData(Array * pArray, DT oldData, DT newData);
void arrayUpdateAllDatas(Array * pArray, DT oldData, DT newData);
//陣列庫擴充功能:
// 1.排序:
// 冒泡->選擇->插入->堆排序->快速(單執行緒)->希爾(多執行緒)
// 2.查詢:
// 二分->插值->多執行緒
// 3.可變引數
// 可變引數擴充
///MyArray.c
#include "MyArray.h"
#include <stdlib.h>
#include <stdio.h>
#include <memory.h>
#include <string.h>
void initArray(Array * pArray)
{
if (NULL == pArray)
{
printf("陣列不存在! \n");
abort();
}
(*pArray).pStart = NULL;
(*pArray).len = 0;
(*pArray).sortState = 0;
}
void initArrayWithData(Array * pArray, DT data)
{
if (NULL == pArray)
{
printf("陣列不存在! \n");
abort();
}
(*pArray).pStart = (DT *)malloc(sizeof(DT));
*((*pArray).pStart) = data;
(*pArray).len = 1;
(*pArray).sortState = 0;
}
void initArrayWithDatas(Array * pArray, DT * pDatas, int pDatasLen)
{
if (NULL == pArray)
{
printf("陣列不存在! \n");
abort();
}
(*pArray).pStart = (DT *)malloc(pDatasLen*sizeof(DT));
memcpy((*pArray).pStart, pDatas, pDatasLen * sizeof(DT));
(*pArray).len = pDatasLen;
(*pArray).sortState = 0;
}
int isValidA(Array * pArray)
{
if (NULL == pArray)
{
printf("陣列不存在! \n");
return 0;
}
return 1;
}
int isValidB(Array * pArray)
{
if (NULL == (*pArray).pStart)
{
printf("陣列無初始化資料! \n");
return 0;
}
return 1;
}
int isValidC(Array * pArray)
{
if (0 == (*pArray).len)
{
printf("陣列沒有資料! \n");
return 0;
}
return 1;
}
int isValidD(Array * pArray)
{
if (NULL == pArray)
{
printf("陣列不存在! \n");
return 0;
}
if (NULL == (*pArray).pStart)
{
printf("陣列無初始化資料! \n");
return 0;
}
return 1;
}
int isValidE(Array * pArray)
{
if (NULL == pArray)
{
printf("陣列不存在! \n");
return 0;
}
if (NULL == (*pArray).pStart)
{
printf("陣列無初始化資料! \n");
return 0;
}
return 1;
}
void printString(Array * pArray)
{
for (int i = 0; i < (*pArray).len; ++i)
{
printf("%s \n", *((*pArray).pStart + i));
}
}
void printInt(Array * pArray)
{
for (int i = 0; i < (*pArray).len; ++i)
{
printf("%d \n", *((*pArray).pStart + i));
}
}
void showArray(Array * pArray, PrintFunP funP)
{
if (!isValidE(pArray))
{
abort();
}
funP(pArray);
}
void arrayAddData(Array * pArray, DT data)
{
if (!isValidA(pArray))
{
abort();
}
if (!isValidB(pArray))
{
initArrayWithData(pArray, data);
}
else
{
(*pArray).pStart = (DT *)realloc((*pArray).pStart, ((*pArray).len + 1) * sizeof(DT));
*((*pArray).pStart + (*pArray).len) = data;
++(*pArray).len;
}
}
void arrayAddDatas(Array * pArray, DT * pDatas, int pDatasLen)
{
if (!isValidA(pArray))
{
abort();
}
if (!isValidB(pArray))
{
initArrayWithDatas(pArray, pDatas, pDatasLen);
}
else
{
(*pArray).pStart = (DT *)realloc((*pArray).pStart, ((*pArray).len + pDatasLen) * sizeof(DT));
memcpy((*pArray).pStart + (*pArray).len, pDatas, pDatasLen * sizeof(DT));
(*pArray).len += pDatasLen;
}
}
int intIsEqual(int * pDataA, int * pDataB)
{
return *pDataA == *pDataB;
}
int strIsEqual(char ** pDataA, char ** pDataB)
{
return !strcmp(*pDataA, *pDataB);
}
DT * arraySelectFirstData(EqualFunP funP, Array * pArray, DT data)
{
if (!isValidE(pArray))
{
abort();
}
for (int i = 0; i < (*pArray).len; ++i)
{
if (funP(&data, (*pArray).pStart + i))
{
return (*pArray).pStart + i;
}
}
return NULL;
}
ResArray arraySelectAllDatas(EqualFunP funP, Array * pArray, DT data)
{
if (!isValidE(pArray))
{
abort();
}
ResArray resArr;
resArr.len = 0;
for (int i = 0; i < (*pArray).len; ++i)
{
if (funP(&data, (*pArray).pStart + i))
{
++resArr.len;
}
}
resArr.ppStart = (DT **)malloc(resArr.len * sizeof(DT *));
int j = 0;
for (int i = 0; i < (*pArray).len; ++i)
{
if (funP(&data, (*pArray).pStart + i))
{
*(resArr.ppStart + j++) = (*pArray).pStart + i;
}
}
return resArr;
}
void arrayInsertData(Array * pArray, DT data, DT insertData)
{
if (!isValidE(pArray))
{
abort();
}
DT * pFindData = arraySelectFirstData(strIsEqual, pArray, data);
if (NULL == pFindData)
{
printf("沒有找到待插入的位置! \n");
abort();
}
int relPos = pFindData - (*pArray).pStart;
(*pArray).pStart = (DT *)realloc((*pArray).pStart, ((*pArray).len + 1)*sizeof(DT));
for (int i = (*pArray).len; i >= relPos; --i)
{
*((*pArray).pStart + i + 1) = *((*pArray).pStart + i);
}
*((*pArray).pStart + relPos) = insertData;
++(*pArray).len;
}
void arrayInsertDatas(Array * pArray, DT data, DT * pInsertDatas, int pInsertDatasLen)
{
if (!isValidE(pArray))
{
abort();
}
DT * pFindData = arraySelectFirstData(strIsEqual, pArray, data);
if (NULL == pFindData)
{
printf("沒有找到待插入的位置! \n");
abort();
}
int relPos = pFindData - (*pArray).pStart;
(*pArray).pStart = (DT *)realloc((*pArray).pStart, ((*pArray).len + pInsertDatasLen) * sizeof(DT));
for (int i = (*pArray).len; i >= relPos; --i)
{
*((*pArray).pStart + i + pInsertDatasLen) = *((*pArray).pStart + i);
}
memcpy((*pArray).pStart + relPos, pInsertDatas, pInsertDatasLen * sizeof(DT));
(*pArray).len += pInsertDatasLen;
}
void arrayDeleteFirstData(Array * pArray, DT data)
{
if (!isValidE(pArray))
{
abort();
}
DT * pFindData = arraySelectFirstData(strIsEqual, pArray, data);
if (NULL == pFindData)
{
printf("沒有找到待刪除的位置! \n");
abort();
}
int relPos = pFindData - (*pArray).pStart;
for (int i = relPos; i < (*pArray).len - 1; ++i)
{
*((*pArray).pStart + i) = *((*pArray).pStart + i + 1);
}
--(*pArray).len;
(*pArray).pStart = (DT *)realloc((*pArray).pStart, (*pArray).len * sizeof(DT));
}
void arrayDeleteAllDatas(Array * pArray, DT data)
{
if (!isValidE(pArray))
{
abort();
}
for (DT * p = arraySelectFirstData(strIsEqual, pArray, data); NULL != p; p = arraySelectFirstData(strIsEqual, pArray, data))
{
arrayDeleteFirstData(pArray, data);
}
}
void arrayUpdateFirstData(Array * pArray, DT oldData, DT newData)
{
if (!isValidE(pArray))
{
abort();
}
DT * pFindData = arraySelectFirstData(strIsEqual, pArray, oldData);
if (NULL == pFindData)
{
printf("未能找到待更新的位置! \n");
abort();
}
*pFindData = newData;
}
void arrayUpdateAllDatas(Array * pArray, DT oldData, DT newData)
{
if (!isValidE(pArray))
{
abort();
}
for (DT * p = arraySelectFirstData(strIsEqual, pArray, oldData); NULL != p; p = arraySelectFirstData(strIsEqual, pArray, oldData))
{
*p = newData;
}
}
///main.c
#include "MyArray.h"
#include <stdlib.h>
#include <stdio.h>
int main01(void)
{
Array array;
initArray(&array);
//initArrayWithData(&array, 1);
//int intArr[5] = { 1, 2, 3, 4, 5 };
//initArrayWithDatas(&array, intArr, 5);
//arrayAddData(&array, 6);
//int intArr1[3] = { 7, 8, 9 };
//arrayAddDatas(&array, intArr1, 3);
//showArray(&array, printInt);
initArrayWithData(&array, "123");
char * pArr[5] = { "abc", "def", "ghi", "jkl", "jkl" };
initArrayWithDatas(&array, pArr, 5);
arrayAddData(&array, "opq");
char * pArr1[3] = { "rst", "uvw", "xyz" };
arrayAddDatas(&array, pArr1, 3);
arrayInsertData(&array, "jkl", "AAA");
char * pArr2[3] = { "BBB", "CCC", "DDD" };
arrayInsertDatas(&array, "jkl", pArr2, 3);
arrayDeleteFirstData(&array , "AAA");
arrayDeleteAllDatas(&array, "jkl");
arrayUpdateFirstData(&array, "BBB", "EEE");
arrayUpdateAllDatas(&array, "CCC", "FFF");
showArray(&array, printString);
//printf("%s \n", *(arraySelectFirstData(strIsEqual, &array, "uvw")));
//ResArray resArr = arraySelectAllDatas(strIsEqual, &array, "jkl");
//for (int i = 0; i < resArr.len; ++i)
//{
// printf("%s \n", **(resArr.ppStart + i));
//}
system("pause");
}
程式片段(03):String.h+Array.h+String.c+Array.c+main.c
內容概要:庫中庫
///String.h
#pragma once
#include <stdlib.h>
typedef struct
{
char * pAStr;
int memLen;
}AString;
typedef struct
{
wchar_t * pWStr;
int memLen;
}WString;
void setWStrLocale(char const * pStr);
int strIsValidA(void * pStr);
int strIsValidB(char chr, void * pStr);
int strIsValidC(char chr, void * pStr);
void initStr(char chr, void * pStr);
void initStrWithStr(char chr, void * pStr, void const * pInitStr);
void showStr(char chr, void * pStr);
///Array.h
#pragma once
typedef struct
{
int eleSize;
int len;
char eleType[12];
void * pArr;
}Array;
void initArray(Array * pArr, char eleType[12], int eleSize);
void initArrayWithDatas(Array * pArr, char eleType[12], int eleSize, void * pInitDatas, int pInitDatasLen);
void showArray(Array * pArr, char eleType[12]);
void arrayAddData(Array * pArr, void * pData);
///String.c
#define _CRT_SECURE_NO_WARNINGS
#include "String.h"
#include <locale.h>
#include <string.h>
#include <stdio.h>
void setWStrLocale(char const * pStr)
{
setlocale(LC_ALL, pStr);
}
int strIsValidA(void * pStr)
{
if (NULL == pStr)
{
printf("字串不存在! \n");
return 0;
}
return 1;
}
int strIsValidB(char chr, void * pStr)
{
if ('w' == chr)
{
WString * pAStr = pStr;
if (NULL == (*pAStr).pWStr)
{
printf("寬字串無初始化資料! \n");
return 0;
}
}
else
{
AString * pWStr = pStr;
if (NULL == (*pWStr).pAStr)
{
printf("寬字串無初始化資料! \n");
return 0;
}
}
return 1;
}
int strIsValidC(char chr, void * pStr)
{
if ('w' == chr)
{
WString * pWStr = pStr;
if (0 == wcslen((*pWStr).pWStr))
{
printf("寬字串沒有資料! \n");
return 0;
}
}
else
{
AString * pAStr = pStr;
if (0 == strlen((*pAStr).pAStr))
{
printf("窄字串沒有資料! \n");
return 0;
}
}
return 1;
}
void initStr(char chr, void * pStr)
{
if (!strIsValidA(pStr))
{
abort();
}
if ('w' == chr)
{
WString * pWStr = pStr;
(*pWStr).pWStr = NULL;
(*pWStr).memLen = 0;
}
else
{
AString * pAStr = pStr;
(*pAStr).pAStr = NULL;
(*pAStr).memLen = 0;
}
}
void initStrWithStr(char chr, void * pStr, void * pInitStr)
{
if (!strIsValidA(pStr))
{
abort();
}
if ('w' == chr)
{
WString * pWStr = pStr;
wchar_t * pInitWStr = pInitStr;
int pWStrLen = wcslen(pInitWStr) + 1;
(*pWStr).pWStr = (wchar_t *)malloc(pWStrLen * 2);
wcscpy((*pWStr).pWStr, pInitWStr);
(*pWStr).memLen = pWStrLen;
}
else
{
AString * pAStr = pStr;
char * pInitAStr = pInitStr;
int pAStrLen = strlen(pInitAStr) + 1;
(*pAStr).pAStr = (char *)malloc(pAStrLen * sizeof(char));
strcpy((*pAStr).pAStr, pInitAStr);
(*pAStr).memLen = pAStrLen;
}
}
void showStr(char chr, void const * pStr)
{
if (!strIsValidA(pStr) || !strIsValidB(chr, pStr) || !strIsValidC(chr ,pStr))
{
abort();
}
if ('w' == chr)
{
WString * pWStr = pStr;
wprintf(L"%ls \n", (*pWStr).pWStr);
}
else
{
AString * pAStr = pStr;
printf("%s \n", (*pAStr).pAStr);
}
}
///Array.c
#define _CRT_SECURE_NO_WARNINGS
#include "Array.h"
#include "String.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
void initArray(Array * pArr, char eleType[12], int eleSize)
{
pArr->pArr = NULL;
pArr->len = 0;
pArr->eleSize = eleSize;
strcpy(pArr->eleType, eleType);
}
void initArrayWithDatas(Array * pArr, char eleType[12], int eleSize, void * pInitDatas, int pInitDatasLen)
{
strcpy((*pArr).eleType, eleType);
(*pArr).eleSize = eleSize;
if (!strcmp("WString", eleType))
{
WString * pWStr = pInitDatas;
(*pArr).pArr = (WString *)malloc(pInitDatasLen * sizeof(WString));
memcpy((*pArr).pArr, pWStr, pInitDatasLen * sizeof(WString));
(*pArr).len = pInitDatasLen;
}
else if (!strcmp("AString", eleType))
{
AString * pAStr = pInitDatas;
(*pArr).pArr = (AString *)malloc(pInitDatasLen * sizeof(AString));
memcpy((*pArr).pArr, pAStr, pInitDatasLen * sizeof(AString));
(*pArr).len = pInitDatasLen;
}
}
void showArray(Array * pArr, char eleType[12])
{
if (!strcmp("WString", eleType))
{
WString * pWStr = (*pArr).pArr;
for (int i = 0; i < (*pArr).len; ++i)
{
wprintf(L"%ls \n", (*(pWStr + i)).pWStr);
}
printf("\n");
}
else if (!strcmp("AString", eleType))
{
AString * pAStr = (*pArr).pArr;
for (int i = 0; i < (*pArr).len; ++i)
{
printf("%s \n", (*(pAStr + i)).pAStr);
}
printf("\n");
}
}
void arrayAddData(Array * pArr, void * pData)
{
if (!strcmp("WString", (*pArr).eleType))
{
(*pArr).pArr = (WString *)realloc((*pArr).pArr, ((*pArr).len + 1)*sizeof(WString));
WString * pWStr = pData;
WString * pTmp = (*pArr).pArr;
*(pTmp + (*pArr).len) = *pWStr;
++(*pArr).len;
}
else if (!strcmp("AString", (*pArr).eleType))
{
(*pArr).pArr = (AString *)realloc((*pArr).pArr, ((*pArr).len + 1)* sizeof(AString));
AString * pAStr = pData;
AString * pTmp = (*pArr).pArr;
*(pTmp + (*pArr).len) = *pAStr;
++(*pArr).len;
}
}
///main.c
#include "String.h"
#include "Array.h"
int main01(void)
{
setWStrLocale("zh-CN");
AString astring;
WString wstring;
//initStr('a', &pAStr);
//initStr('w', &pWStr);
initStrWithStr('a', &astring, "calc");
initStrWithStr('w', &wstring ,L"你猜猜");
showStr('a', &astring);
showStr('w', &wstring);
system("pause");
}
程式片段(04):Row.h+Array.h+init.h+Row.c+Array.c+init.c
內容概要:資料的管理-增刪查改線性儲存
///Row.h
#pragma once
typedef struct
{
long long QQ;
char * pStr;
unsigned char len;
}Row;
int rowIsValidA(Row * pRow);
int rowIsValidB(Row * pRow);
int rowIsValidC(Row * pRow);
void initRowWithData(Row * pRow, long long QQ, char * pStr);
void initRowWithPass(Row * pRow, char * pPass);
void initRowWithStr(Row * pRow, char * pStr);
void showRow(Row * pRow);
void rowUpdateRow(Row * pOldRow, Row * pNewRow);
void rowUpdateRowDeep(Row * pOldRow, Row * pNewRow);
///Array.h
#pragma once
#include "Row.h"
typedef struct
{
Row * pRow;
int len;
}Array;
void initArray(Array * pArr);
void initArrayWithStr(Array * pArr, char * pStr);
void showArray(Array * pArr);
void arraySelectDataByFirstQQ(Array * pArr, long long QQ);
void arraySelectDataByAllQQ(Array * pArr, long long QQ);
void arraySelectDataByFirstPass(Array * pArr, char * pPass);
void arraySelectDataByAllPass(Array * pArr, char * pPass);
void arrayAddData(Array * pArr, Row * pRow);
void arrayInsertDataByFirstQQ(Array * pArr, long long QQ, Row * pRow);
void arrayInsertDataByAllQQ(Array * pArr, long long QQ, Row * pRow);
void arrayInsertDataByFirstPass(Array * pArr, char * pPass, Row * pRow);
void arrayInsertDataByAllPass(Array * pArr, char * pPass, Row * pRow);
void arrayDeleteAllDatas(Array * pArr);
void arrayDeleteDataByFirstQQ(Array * pArr, long long QQ);
void arrayDeleteDataByAllQQ(Array * pArr, long long QQ);
void arrayDeleteDataByFirstPass(Array * pArr, char * pPass);
void arrayDeleteDataByAllPass(Array * pArr, char * pPass);
void arrayUpdateDataByFirstQQ(Array * pArr, long long QQ, Row * pRow);
void arrayUpdateDataByAllQQ(Array * pArr, long long QQ, Row * pRow);
void arrayUpdateDataByFirstPass(Array * pArr, char * pPass, Row * pRow);
void arrayUpdateDataByAllPass(Array * pArr, char * pPass, Row * pRow);
int comByQQ(Row * pQQA, Row * pQQB);
int comByPass(Row * pPassA, Row * pPassB);
void sortByQQ(Array * pArr);
void sortByPass(Array * pArr);
///init.h
#pragma once
//01.全域性變數位於靜態區,與程式共存亡:
// 函式和全域性變數的宣告可以有多個;
// 但是定義只能有一個
char str[1024];
int num;
int countRow(char * pStr);
///Row.c
#include "Row.h"
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
int rowIsValidA(Row * pRow)
{
if (NULL == pRow)
{
printf("行結構不存在! \n");
return 0;
}
return 1;
}
int rowIsValidB(Row * pRow)
{
if (NULL == (*pRow).pStr)
{
printf("行結構無初始資料行! \n");
return 0;
}
return 1;
}
int rowIsValidC(Row * pRow)
{
if (0 == (*pRow).len)
{
printf("行結構無資料行! \n");
return 0;
}
return 1;
}
void initRowWithData(Row * pRow, long long QQ, char * pStr)
{
if (!rowIsValidA(pRow))
abort();
(*pRow).QQ = QQ;
int len = strlen(pStr);
(*pRow).pStr = (char *)malloc((len + 1)*sizeof(char));
strcpy((*pRow).pStr, pStr);
(*pRow).len = len + 1;
}
void initRowWithPass(Row * pRow, char * pPass)
{
if (!rowIsValidA(pRow))
abort();
(*pRow).QQ = 77025077;
int initStrLen = strlen(pPass) + 1;
(*pRow).pStr = (char *)malloc(initStrLen * sizeof(char));
strcpy((*pRow).pStr, pPass);
(*pRow).len = initStrLen;
}
void initRowWithStr(Row * pRow, char * pInitStr)
{
if (!rowIsValidA(pRow))
abort();
char * p = strstr(pInitStr, "----");
*p = '\0';
sscanf(p, "%lld", &(*pRow).QQ);
int pInitStrLen = strlen(p + 4);
(*pRow).pStr = (char *)malloc((pInitStrLen + 1) * sizeof(char));
strcpy((*pRow).pStr, pInitStr);
(*pRow).len = pInitStrLen + 1;
}
void showRow(Row * pRow)
{
if (!rowIsValidA(pRow) || !rowIsValidB(pRow) || !rowIsValidC(pRow))
abort();
printf("%lld<--->%s \n", (*pRow).QQ, (*pRow).pStr);
}
void rowUpdateRow(Row * pOldRow, Row * pNewRow)
{
if (!rowIsValidA(pOldRow) || !rowIsValidA(pNewRow))
abort();
*pOldRow = *pNewRow;
}
void rowUpdateRowDeep(Row * pOldRow, Row * pNewRow)
{
if (!rowIsValidA(pOldRow) || !rowIsValidA(pNewRow))
abort();
*pOldRow = *pNewRow;
(*pOldRow).pStr = (char *)malloc((strlen((*pNewRow).len + 1) * sizeof(char)));
strcpy((*pOldRow).pStr, (*pNewRow).pStr);
}
///Array.c
#include "Array.h"
#include <stdlib.h>
#include <string.h>
#include "Row.h"
#include "init.h"
int arrIsValidA(Array * pArr)
{
if (NULL == pArr)
{
printf("陣列不存在! \n");
return 0;
}
return 1;
}
int arrIsValidB(Array * pArr)
{
if (NULL == (*pArr).pRow)
{
printf("陣列未初始化資料! \n");
return 0;
}
return 1;
}
int arrIsValidC(Array * pArr)
{
if (0 == (*pArr).len)
{
printf("陣列無資料! \n");
return 0;
}
return 1;
}
void initArray(Array * pArr)
{
if (!arrIsValidA(pArr))
{
abort();
}
(*pArr).pRow = NULL;
(*pArr).len = 0;
}
void initArrayWithStr(Array * pArr, char * pStr)
{
if (!arrIsValidA(pArr))
{
abort();
}
int rowNum = countRow(pStr);
(*pArr).pRow = (Row *)malloc(rowNum * sizeof(Row));
(*pArr).len = rowNum;
int pStrLen = strlen(pStr);
for (char * p = pStr; p < pStr + pStrLen; p += strlen(p) + 1)
{//字串預處理
if (' ' == *p)
{
*p = '\0';
}
}
int i = 0;
for (char * p = pStr; p < pStr + pStrLen; p += strlen(p) + 1)
{
char * pTmp = (char *)malloc((strlen(p) + 1) * sizeof(char));
strcpy(pTmp, p);
initRowWithStr((*pArr).pRow + i++, pTmp);
}
}
void showArray(Array * pArr)
{
if (!arrIsValidA(pArr) || !arrIsValidB(pArr) || !arrIsValidC(pArr))
abort();
for (int i = 0; i < (*pArr).len; ++i)
{
showRow((*pArr).pRow + i);
}
}
void arraySelectDataByFirstQQ(Array * pArr, long long QQ)
{
if (!arrIsValidA(pArr) || !arrIsValidB(pArr) || !arrIsValidC(pArr))
abort();
for (int i = 0; i < (*pArr).len; ++i)
{
if (QQ == (*((*pArr).pRow + i)).QQ)
{
printf("找到了首個QQ:%lld, pass:%s \n", QQ, (*((*pArr).pRow + i)).pStr);
printf("資料查詢結束! \n");
return;
}
}
}
void arraySelectDataByAllQQ(Array * pArr, long long QQ)
{
if (!arrIsValidA(pArr) || !arrIsValidB(pArr) || !arrIsValidC(pArr))
abort();
for (int i = 0; i < (*pArr).len; ++i)
{
if (QQ == (*((*pArr).pRow + i)).QQ)
{
printf("QQ:%lld, pass:%s \n", QQ, (*((*pArr).pRow + i)).pStr);
}
}
printf("資料查詢結束! \n");
}
void arraySelectDataByFirstPass(Array * pArr, char * pPass)
{
if (!arrIsValidA(pArr) || !arrIsValidB(pArr) || !arrIsValidC(pArr))
abort();
for (int i = 0; i < (*pArr).len; ++i)
{
if (NULL != strstr((*((*pArr).pRow + i)).pStr, pPass))
{
printf("首次找到了QQ:%lld, pass:%s \n", (*((*pArr).pRow + i)).QQ, (*((*pArr).pRow + i)).pStr);
printf("資料查詢結束! \n");
return;
}
}
}
void arraySelectDataByAllPass(Array * pArr, char * pPass)
{
if (!arrIsValidA(pArr) || !arrIsValidB(pArr) || !arrIsValidC(pArr))
abort();
for (int i = 0; i < (*pArr).len; ++i)
{
if (NULL != strstr((*((*pArr).pRow + i)).pStr, pPass))
{
printf("QQ:%lld, pass:%s \n", (*((*pArr).pRow + i)).QQ, (*((*pArr).pRow + i)).pStr);
}
}
printf("資料查詢完畢! \n");
}
void arrayAddData(Array * pArr, Row * pData)
{
if (!arrIsValidA(pArr))
abort();
(*pArr).pRow = (Row *)realloc((*pArr).pRow, ((*pArr).len + 1) * sizeof(Row));
*((*pArr).pRow + (*pArr).len) = *pData;
++(*pArr).len;
}
void arrayInsertDataByFirstQQ(Array * pArr, long long QQ, Row * pRow)
{
if (!arrIsValidA(pArr) || !arrIsValidB(pArr) || !arrIsValidCI(pArr))
abort();
int relPos = -1;
for (int i = 0; i < (*pArr).len; ++i)
{
if (QQ == (*((*pArr).pRow + i)).QQ)
{
relPos = i;
printf("找到首個QQ:%lld, pass:%s \n", (*(QQ, (*pArr).pRow + i)).pStr);
break;
}
}
if (-1 == relPos)
{
printf("沒有找到將要插入的位置! \n");
abort();
}
(*pArr).pRow = (Row *)realloc((*pArr).pRow, ((*pArr).len + 1) * sizeof(Row));
for (int i = (*pArr).len; i >= relPos; --i)
{
*((*pArr).pRow + i + 1) = *((*pArr).pRow + i);
}
*((*pArr).pRow + relPos) = *pRow;
++(*pArr).len;
}
void arrayInsertDataByAllQQ(Array * pArr, long long QQ, Row * pRow)
{
if (!arrIsValidA(pArr) || !arrIsValidB(pArr) || !arrIsValidC(pArr))
abort();
int i = 0;
int j = 0;
while (1)
{
if (i >= (*pArr).len || j >= (*pArr).len)
{
break;
}
*((*pArr).pRow + i) = *((*pArr).pRow + j);
if (QQ == ((*pArr).pRow + i))
{
(*pArr).pRow = (Row *)realloc((*pArr).pRow, ((*pArr).len + 1) * sizeof(Row));
for (int k = (*pArr).len - 1; k >= i; --k)
{
*((*pArr).pRow + k + 1) = *((*pArr).pRow + k);
}
*((*pArr).pRow + i) = *pRow;
++(*pArr).len;
i += 2;//跳到下一起點
j += 2;
}
else
{
++j;
++i;
}
}
}
void arrayInsertDataByFirstPass(Array * pArr, char * pPass, Row * pRow)
{
if (!arrIsValidA(pArr) || !arrIsValidB(pArr) || !arrIsValidC(pArr))
abort();
int relPos = -1;
for (int i = 0; i < (*pArr).len; ++i)
{
if (!strcmp(pPass, (*((*pArr).pRow + i)).pStr))
{
relPos = i;
break;
}
}
if (-1 == relPos)
{
abort();
}
(*pArr).pRow = (Row *)realloc((*pArr).pRow, ((*pArr).len + 1) * sizeof(Row));
for (int i = (*pArr).len; i >= relPos; --i)
{
*((*pArr).pRow + i + 1) = *((*pArr).pRow + i);
}
*((*pArr).pRow + relPos) = *pRow;
++(*pArr).len;
}
void arrayInsertDataByAllPass(Array * pArr, char * pPass, Row * pRow)
{
if (!arrIsValidA(pArr) || !arrIsValidB(pArr) || !arrIsValidC(pArr))
abort();
int i = 0, j = 0;
while (1)
{
if (i >= (*pArr).len || j >= (*pArr).len)
{
return;
}
*((*pArr).pRow + i) = *((*pArr).pRow + j);
if (!strcmp((*((*pArr).pRow + i)).pStr, pPass))
{
(*pArr).pRow = (Row *)realloc((*pArr).pRow, ((*pArr).len + 1) * sizeof(Row));
for (int k = (*pArr).len; k >= i; --k)
{
*((*pArr).pRow + k + 1) = *((*pArr).pRow + k);
}
*((*pArr).pRow + i) = *pRow;
j += 2;
i += 2;
}
else
{
++j;
++i;
}
}
}
void arrayDeleteAllDatas(Array * pArr)
{
if (!arrIsValidA(pArr))
abort();
for (int i = 0; i < (*pArr).len; ++i)
{
free((*((*pArr).pRow + i)).pStr);
}
free((*pArr).pRow);
(*pArr).pRow = NULL;
(*pArr).len = 0;
}
void arrayDeleteDataByFirstQQ(Array * pArr, long long QQ)
{
if (!isValidA(pArr) || !arrIsValidB(pArr) || !arrIsValidC(pArr))
abort();
int relPos = -1;
for (int i = 0; i < (*pArr).len; ++i)
{
if (QQ == (*((*pArr).pRow + i)).QQ)
{
relPos = i;
break;
}
}
if (-1 == relPos)
{
abort();
}
free((*((*pArr).pRow + relPos)).pStr);
for (int i = relPos; i < (*pArr).len - 1; ++i)
{
*((*pArr).pRow + i) = *((*pArr).pRow + i + 1);
}
--(*pArr).len;
(*pArr).pRow = (Row *)realloc((*pArr).pRow, (*pArr).len * sizeof(Row));
}
void arrayDeleteDataByAllQQ(Array * pArr, long long QQ)
{
if (!arrIsValidA(pArr) || !arrIsValidB(pArr) || !arrIsValidC(pArr))
abort();
int i = 0, j = 0, k = 0;;
while (1)
{
if (i >= (*pArr).len || j >= (*pArr).len)
break;
*((*pArr).pRow + i) = *((*pArr).pRow + j);
if (QQ == (*((*pArr).pRow + i)).QQ)
{
free((*((*pArr).pRow + i)).pStr);
++j;
++k;
}
else
{
++i;
++j;
}
}
(*pArr).len -= k;
(*pArr).pRow = (Row *)realloc((*pArr).pRow, (*pArr).len * sizeof(Row));
}
void arrayDeleteDataByFirstPass(Array * pArr, char * pPass)
{
if (!arrIsValidA(pArr) || !arrIsValidB(pArr) || !arrIsValidC(pArr))
abort();
int relPos = -1;
for (int i = 0; i < (*pArr).len; ++i)
{
if (!strcmp(pPass, (*((*pArr).pRow + i)).pStr))
{
relPos = i;
break;
}
}
if (-1 == relPos)
{
abort();
}
free((*((*pArr).pRow + relPos)).pStr);
for (int i = relPos; i < (*pArr).len - 1; ++i)
{
*((*pArr).pRow + i) = *((*pArr).pRow + i + 1);
}
--(*pArr).len;
(*pArr).pRow = (Row *)realloc((*pArr).pRow, (*pArr).len * sizeof(Row));
}
void arrayDeleteDataByAllPass(Array * pArr, char * pPass)
{
if (!arrIsValidA(pArr) || !arrIsValidB(pArr) || !arrIsValidC(pArr))
abort();
int i = 0, j = 0, k = 0;
while (1)
{
if (i >= (*pArr).len || j >= (*pArr).len)
break;;
*((*pArr).pRow + i) = *((*pArr).pRow + j);
if (!strcmp(pPass, (*pArr).pRow + i))
{
free((*((*pArr).pRow + i)).pStr);
++k;
++j;
}
else
{
++i;
++j;
}
}
(*pArr).len -= k;
(*pArr).pRow = (Row *)realloc((*pArr).pRow, (*pArr).len * sizeof(Row));
}
void arrayUpdateDataByFirstQQ(Array * pArr, long long QQ, Row * pRow)
{
if (!arrIsValidA(pArr) || !arrIsValidB(pArr) || !arrIsValidC(pArr))
abort();
for (int i = 0; i < (*pArr).len; ++i)
{
if (QQ == (*((*pArr).pRow + i)).QQ)
{
rowUpdateRow((*pArr).pRow + i, pRow);
break;
}
}
}
void arrayUpdateDataByAllQQ(Array * pArr, long long QQ, Row * pRow)
{
if (!arrIsValidA(pArr) || !arrIsValidB(pArr) || !arrIsValidC(pArr))
abort();
for (int i = 0; i < (*pArr).len; ++i)
{
if(QQ == (*((*pArr).pRow + i)).QQ)
{
rowUpdateRow((*pArr).pRow + i, pRow);
}
}
}
void arrayUpdateDataByFirstPass(Array * pArr, char * pPass, Row * pRow)
{
if (!arrIsValidA(pArr) || !arrIsValidB(pArr) || !arrIsValidC(pArr))
abort();
for (int i = 0; i < (*pArr).len; ++i)
{
if (!strcmp(pPass, (*((*pArr).pRow + i)).pStr))
{
rowUpdateRow((*pArr).pRow + i, pRow);
break;
}
}
}
void arrayUpdateDataByAllPass(Array * pArr, char * pPass, Row * pRow)
{
if (!arrIsValidA(pArr) || !arrIsValidB(pArr) || !arrIsValidC(pArr))
abort();
for (int i = 0; i < (*pArr).len; ++i)
{
if (!strcmp(pPass, (*((*pArr).pRow + i)).pStr))
{
rowUpdateRow((*pArr).pRow + i, pRow);
}
}
}
int comByQQ(Row * pDataA, Row * pDataB)
{
if (!rowIsValidA(pDataA) || !rowIsValidA(pDataB))
abort();
if ((*pDataA).QQ < (*pDataB).QQ)
{
return -1;
}
else if ((*pDataA).QQ == (*pDataB).QQ)
{
return 0;
}
else
{
return 1;
}
}
int comByPass(Row * pDataA, Row * pDataB)
{
return strcmp((*pDataA).pStr, (*pDataB).pStr);
}
void sortByQQ(Array * pArr)
{
qsort((*pArr).pRow, (*pArr).len, sizeof(Row), comByQQ);
}
void sortByPass(Array * pArr)
{
qsort((*pArr).pRow, (*pArr).len, sizeof(Row), comByPass);
}
///init.c
#include "init.h"
#include <string.h>
char str[1024]= "521276402----hanlei@19940403 \
286738260----weipei559720 \
501223616----feng66532008 \
77025077----shuidongwo520 \
1340382355----huang.512yang. \
1061817115----fz62wangyong1983 \
347232860----20080811 \
1028181591----7404850554 \
120539543----0.0123456789 \
754229005----460228214 \
819781633----zmt1993826 \
1319148052----ynu1500621032 \
904972448----zhouxiaowen.520 \
750134133----1292857988 \
77025077----320675 \
379644978----7758521tao \
346083956----devl1017 \
77025077----5361a749 ";
int num=0;//定義
int countRow(char * pStr)
{
int rowNum = 0;
for (char * p = strstr(pStr, "----"); NULL != p; p = strstr(p + 4, "----");)
{
++rowNum;
}
return rowNum;
}
程式片段(05):main.c
內容概要:劫持方法解決記憶體洩漏
#include <stdio.h>
#include <stdlib.h>
//01.記憶體洩露:
// 問題:手動開闢的堆記憶體空間沒有進行及時的手動回收
// 解決:劫持技術解決+堆記憶體操作函式包裝(函式包裝)
// 原理:等同於引用計數的特點
//02.防記憶體洩露原理:
// 引用技術原理的使用
typedef struct
{//單記憶體塊兒
void * pStart;//首地址
int memSize;//記憶體尺寸
}Mem;
typedef struct
{//動態陣列
Mem * pMem;//首地址
int memNum;//記憶體塊數
}MemArr;
int i = 0;//全域性變數-->靜態區-->統計記憶體塊兒數
void * myMalloc(size_t size)
{
++i;
return malloc(size);
}
void myFree(void * mem)
{
free(mem);
--i;
}
int main01(void)
{
void * pStart1 = myMalloc(14);
void * pStart2 = myMalloc(14);
void * pStart3 = myMalloc(14);
myFree(pStart1);
printf("%d \n", i);
system("pause");
}
相關文章
- 20160217.CCPP體系詳解(0027天)
- 20160124.CCPP詳解體系(0003天)
- 20160125.CCPP詳解體系(0004天)
- 20160126.CCPP體系詳解(0005天)
- 20160127.CCPP體系詳解(0006天)
- 20160130.CCPP體系詳解(0009天)
- 20160203.CCPP體系詳解(0013天)
- 20160211.CCPP體系詳解(0021天)
- 20160213.CCPP體系詳解(0023天)
- 20160214.CCPP體系詳解(0024天)
- 20160215.CCPP體系詳解(0025天)
- 20160224.CCPP體系詳解(0034天)
- 20160218.CCPP體系詳解(0028天)
- 20160219.CCPP體系詳解(0029天)
- 手遊《天地劫》的三天體驗——深度系統剖析及玩法詳解
- 20160122.CCPP詳解體系(0001天)
- 20160123.CCPP詳解體系(0002天)
- 20160128.CCPP體系詳解(0007天)
- 20160129.CCPP體系詳解(0008天)
- 20160131.CCPP體系詳解(0010天)
- 20160204.CCPP體系詳解(0014天)
- 20160205.CCPP體系詳解(0015天)
- 20160210.CCPP體系詳解(0020天)
- 20160212.CCPP體系詳解(0022天)
- 20160207.CCPP體系詳解(0017天)
- 20160225.CCPP體系詳解(0035天)
- 20160226.CCPP體系詳解(0036天)
- 20160227.CCPP體系詳解(0037天)
- 20160222.CCPP體系詳解(0032天)
- 20160221.CCPP體系詳解(0031天)
- 20160201.CCPP體系詳解(0011天)
- 20160202.CCPP體系詳解(0012天)
- 20160209.CCPP體系詳解(0019天)
- 20160216.CCPP體系詳解(0026天)
- 20160206.CCPP體系詳解(0016天)
- 20160208.CCPP體系詳解(0018天)
- 20160220.CCPP體系詳解(0030天)
- MySQL體系結構詳解MySql