20160222.CCPP体系具体解释(0032天)

程序片段(01):宽字符.c+字符串与内存四区.c

内容概要:宽窄字符

///宽字符.c
#include <stdio.h>
#include <stdlib.h>
#include <locale.h>//01.宽字符的应用:
// 1.宽字符用于国际化:
// Unicode编码情况之下,须要启用宽字符编程
// 2.中文的高级处理:
// 必须依赖于宽字符
// 3.宽窄字符的唯一不同特点:
// 存储数据的盒子尺寸不一致(宽字符採用双字节存储,窄字符採用单字节存储)
// 注:其它特性和窄字符一致
// 4.宽字符情况之下:
// 全部单个宽字符都占领两个字节的内存空间
// 5.设置本地化的目的:
// 启用本地字符集,以实现基于本地化的国际化
// 注:
// 1.L'X'-'X'和L"ABC"-"ABC"两种存储方式存储的数据实质都是一样的,不一样的
// 仅仅是存储该数据的盒子尺寸不一样
// 2.宽窄字符的使用注意事项:
// 宽字符:
// 假设没有设置本地化的情况之下,也就仅仅能处理ASCII码表包括字符
// 仅仅有在设置了正确的本地化的情况之下,才干正确的处理本地语言
// 窄字符:
// 不管是否设置本地化,都仅仅能处理ASCII码表其中所定义的字符
// 也就是说仅仅有宽字符才存在设置本地化的不同点
// 3.宽窄字符的结尾标识符:
// 宽字符:L'\0'
// 窄字符:'\0
// 注:全部位于代码区常量池的字符串默认携带结尾标识符
//02.採用窄字符存储中文的特点分析:
// 1.全部ASCII码表所包括的字符都仅仅占用一个字节
// 2.全部中文字符将会包括两个字节
// 注:窄字符存储原理
int main01(void)
{
char * p1 = "我";
char * p2 = "我的";//全部位于代码区常量池的字符串结尾默认自带'\0'orL'\0'
printf("%d, %d \n", sizeof("我"), sizeof("我的"));
printf("%s \n", p1);//窄字符情况下:分ASCII码表字符和非ASCII码表字符 system("pause");
}//03.非ASCII码表的其它字符假设依照字符数组进行存储:
// 就须要依照其它字符所占领的字节个数进行连续字符的打印,这样才干正确
// 的还原字符数组其中所存储的字符串内容
int main02(void)
{
char str[10] = "我";//非ASCII码表内容依照窄字符数组存储,须要依照连续的单字节个数进行字符解析
printf("%c%c \n", *(str + 0), *(str + 1));//方能正确的显示非ASCII码表字符串 system("pause");
}//04.宽窄字符使用注意事项:
// 1.严格区分宽窄字符
// 2.严格区分单字符还是字符串:
// 单字符:就是单个字符
// 字符串:含有结束标识
// 3.严格区分占用字节和使用字节:
//注:认真区分宽窄字符的存储原理!
int main03(void)
{
wchar_t wchr1 = L'我';
wchar_t wstr[10] = L"我的C";
printf("%d \n", sizeof(wchr1));//2
printf("%d \n", sizeof(wstr));//20
printf("%d \n", sizeof(L"我的C1"));//宽字符:不管是何种字符,都依照两个字节进行存储 system("pause");
}//05.宽窄字符都遵守内存四区理论
int main04(void)
{
wchar_t * p = L"我的C";//宽窄字符都遵从内存四区理论
*p = L'X'; system("pause");
}//06.不管是宽字符的字符还是字符串:
// 都必须要求加入上宽字符前缀标识L
// 宽字符(单字符):L''
// 宽字符(字符串):L""
//07.宽字符细节问题:
// 1.宽字符(单字符):
// 外部标识:L''
// 格式控制:%c
// 2.宽字符(字符串)
// 外部标识:L""
// 格式控制:%ls
//注:宽字符最好同一时候使用(本地化)+(宽字符标识)+(宽字符函数)+(宽字符格式控制)
// 这样宽字符才干保证全然正确的显示
int main05(void)
{
setlocale(LC_ALL, "zh-CN");
wchar_t * pWChr = L"12345abcdef我的王";
//printf("%s \n", pWChr);//类型不匹配
wprintf(L"wprintf = %ls \n", pWChr); system("pause");
}int main06(void)
{
setlocale(LC_ALL, L"zh-CN");
wchar_t wchr = L'我';
putwchar(wchr); system("pause");
}

///字符串与内存四区.c
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>char str[100] = "12345";//01.除了代码区其中的内容不可进行改动,其它地儿差点儿都能够:
// 代码区常量池:直接获取
// 代码区符号表:先读取,再生成,最后才干使用
int main07(void)
{
char * pStr1 = "ABCDEF";//代码区
char str[100] = "1234567";//栈内存
char * pStr2 = (char *)malloc(100);//堆内存
strcpy(pStr2, "ABCDEF");
//*pStr1 = 'X';
*pStr2 = 'X';
*str = 'X';
char * pChr = str;
printf("%s, %s, %s \n", pStr1, str, pStr2); system("pause");
}int main08(void)
{
char * pStr1 = "ABCDEF";
char * pStr2 = "ABCDEF";//代码区常量池其中的同样常量字符串仅仅有一份儿(地址同样)
char str1[10] = "ABCDEF";
char str2[10] = "ABCDEF";
char * pM1 = (char *)malloc(10);
char * pM2 = (char *)malloc(10);
strcpy(pM1, "ABCDEF");
strcpy(pM2, "ABCDEF");
printf("%d, %d, %d \n", pStr1 == pStr2, str1 == str2, pM1 == pM2); system("pause");
}char strX[100] = "ABCDEF";
char * getStr()
{
char str[100] = "ABCDEF";//返回栈内存不能够
char * pStr = "ABCDEF";//代码区地址
char * pStrX = strX;//静态区地址
return pStrX;
}//02.函数的返回值所能返回的指针特点:
// 1.绝对不能返回指向栈内存的指针
// 2.返回指向栈内存的指针属于迷途指针:
// 迷途指针:指针所指向的内存块儿已经被回收了
int main09(void)
{
char * pStr;
pStr = getStr();
printf("\n\n\n");
free(pStr);//迷途指针
pStr == NULL;//指针为空
printf("%s \n", pStr); system("pause");
}

程序片段(02):MyString.h+MyString.c+main.c

内容概要:字符串库封装

///MyString.h
#pragma once
#include <stdlib.h>typedef struct
{
char * pAStr;//首地址
int memLen;//实际长
} MyAString;typedef struct
{
wchar_t * pWStr;
int memLen;
} MyWString;//指定初始
void initMyAStrWithAStr(MyAString * pMyAStr, char const * pAStr);
void initMyWStrWithWStr(MyWString * pMyWStr, wchar_t const * pWStr);//显示字串
void showMyAStr(MyAString * pMyAStr);
void showMyWStr(MyWString * pMyWStr);//字串长度
int myAStrLen(MyAString * pMyAStr);
int myWStrLen(MyWString * pMyWstr);//字串拷贝
MyAString * myAStrCpy(MyAString * pMyAStr, char const * pAStr);
MyWString * myWStrCpy(MyWString * pMyWStr, wchar_t const * pWStr);//递归拷贝
MyAString * myAStrCopy(MyAString * pMyAStr, char const * pAStr, int i);
MyWString * myWStrCopy(MyWString * pMyWStr, wchar_t const * pWStr, int i);//尾部追加
void myAStrAddAStr(MyAString * pMyAStr, char const * pAStr);
void myWStrAddWStr(MyWString * pMyWStr, wchar_t const * pWStr);//字串查找
char * myAStrAStr(MyAString * pMyAStr, char * pAStr);
wchar_t * myWStrWStr(MyWString * pMyWStr, wchar_t * pWStr);//随机前插
void myAStrPrevInsertAStr(MyAString * pMyAStr, char * pAStr, char * pInsertAStr);
void myWStrPrevInsertWStr(MyWString * pMyWstr, wchar_t * pWStr, wchar_t * pInsertWStr);//随机后插
void myAStrNextInsertAStr(MyAString * pMyAStr, char * pAStr, char * pInsertAStr);
void myWStrNextInsertWStr(MyWString * pMyWStr, wchar_t * pWStr, wchar_t * pInsertWStr );//删除单个
void myAStrDelFirstAStr(MyAString * pMyAStr, char * pAStr);
void myWStrDelFirstWStr(MyWString * pMyWStr, wchar_t * pWStr);//删除多个
void myAStrDelAllAStr(MyAString * pMyAStr, char * pAStr);
void myWStrDelAllWStr(MyWString * pMyWStr, wchar_t * pWStr);
void myAStrDelAllAStrByRec(MyAString * pMyAStr, char * pAStr);
void myWStrDelAllWStrByRec(MyWString * pMyWStr, wchar_t * pWStr);//随机替换(低效率)
void myAStrRepFirstAStrLow(MyAString * pMyAStr, char * pAStr, char * pRepAStr);
void myWStrRepFirstWStrLow(MyWString * pMyWStr, wchar_t * pWStr, wchar_t * pRepWStr);
void myAStrRepAllAStrLow(MyAString * pMyAStr, char * pAStr, char * pRepAStr);
void myWStrRepAllWStrLow(MyWString * pMyWStr, wchar_t * pWStr, wchar_t * pRepStr);//随机替换(高效率)
void myAStrRepFirstAStrHigh(MyAString * pMyAStr, char * pAStr, char * pRepAStr);
void myWStrRepFirstWStrHigh(MyWString * pMyWStr, wchar_t * pWStr, wchar_t * pRepWStr);
void myAStrRepAllAStrHigh(MyAString * pMyAStr, char * pAStr, char * pRepAStr);
void myWStrRepAllWStrHigh(MyWString * pMyWStr, wchar_t * pWStr, wchar_t * pRepWStr);//扩充功能:
//字符串压缩:
// 1.时间优先or空间优先
// 2.单字符压缩和字符串压缩

///MyString.c
#define _CRT_SECURE_NO_WARNINGS
#include "MyString.h"
#include <string.h>
#include <stdio.h> void showMyAStr(MyAString * pMyAStr)
{
if (NULL == pMyAStr->pAStr)
return;
printf("%s \n", pMyAStr->pAStr);
}void showMyWStr(MyWString * pMyWStr)
{
if (NULL == pMyWStr->pWStr)
return;
wprintf(L"%ls \n", pMyWStr->pWStr);
}int myAStrLen(MyAString * pMyAStr)
{
if (NULL == pMyAStr)
return 0;
int i = 0;
while (*pMyAStr->pAStr++)
{
++i;
} return i;
}int myWStrLen(MyWString * pMyWStr)
{
if (NULL == pMyWStr)
return 0;
int i = 0;
while (*pMyWStr->pWStr++)
{
++i;
} return i;
}MyAString * myAStrCpy(MyAString * pMyAStr, char const * pAStr)
{
if (NULL == pMyAStr || NULL == pAStr)
return NULL;
//pAStrLen = strlen(pAStr);
//for (int i = 0; i < pAStrlen + 1; ++i)
//{
// *(pMyAStr->pAStr + i) = *(pAStr + i);
//}
char * pCopy = pMyAStr->pAStr;
while (*pCopy++ = *pAStr++);
return pMyAStr;
}MyWString * myWStrCpy(MyWString * pMyWStr, wchar_t const * pWStr)
{
if (NULL == pMyWStr || NULL == pWStr)
return NULL;
//int pWStrLen = wcslen(pWStr);
//for (int i = 0; i < pWStrLen + 1; ++i)
//{
// *(pMyWStr->pWStr + i) = *(pWStr + i);
//}
wchar_t * pCopy = pMyWStr->pWStr;
while (*pCopy++ = *pWStr++);
return pMyWStr;
}MyAString * myAStrCopy(MyAString * pMyAStr, char const * pAStr, int i)
{
if (!(*(pMyAStr->pAStr + i) = *(pAStr + i++)))
return pMyAStr;
myAStrCopy(pMyAStr, pAStr, i);
}MyWString * myWStrCopy(MyWString * pMyWStr, wchar_t const * pWStr, int i)
{
//static char * pTemp = pWStr;//静态局部变量不能使用变量进行初始化
if (!(*(pMyWStr->pWStr + i) = *(pWStr + i++)))
return pMyWStr;
myWStrCopy(pMyWStr, pWStr, i);
}void initMyAStrWithAStr(MyAString * pMyAStr, char const * pAStr)
{
if (NULL == pMyAStr || NULL == pAStr)
abort();
int myStrLen = strlen(pAStr) + 1;
pMyAStr->pAStr = (char *)malloc(myStrLen * sizeof(char));
//myAStrCpy(pMyAStr, pAStr);
myAStrCopy(pMyAStr, pAStr, 0);
pMyAStr->memLen = myStrLen + 1;
}void initMyWStrWithWStr(MyWString * pMyWStr, wchar_t const * pWStr)
{
if (NULL == pMyWStr || NULL == pWStr)
abort();
int myWStrLen = wcslen(pWStr) + 1;
pMyWStr->pWStr = (wchar_t *)malloc(myWStrLen * sizeof(wchar_t));
//myWStrCpy(pMyWStr, pWStr);
myWStrCopy(pMyWStr, pWStr, 0);
pMyWStr->memLen = myWStrLen;
}void myAStrAddAStr(MyAString * pMyAStr, char const * pAStr)
{
if (NULL == pMyAStr || NULL == pAStr)
abort();
if (NULL == pMyAStr)
{
initMyAStrWithAStr(pMyAStr, pAStr);
}
else
{
int myAStrLen = strlen(pMyAStr->pAStr);
int addAStrLen = strlen(pAStr);
int allAStrLen = myAStrLen + addAStrLen + 1;
if (pMyAStr->memLen < allAStrLen)
{
pMyAStr->pAStr = (char *)realloc(pMyAStr->pAStr, allAStrLen * sizeof(char));
pMyAStr->memLen = allAStrLen;
}
strcat(pMyAStr->pAStr, pAStr);
}
}void myWStrAddWStr(MyWString * pMyWStr, wchar_t const * pWStr)
{
if (NULL == pMyWStr || NULL == pWStr)
abort();
if (NULL == pMyWStr->pWStr)
{
initMyWStrWithWStr(pMyWStr, pWStr);
}
else
{
int myWStrLen = wcslen(pMyWStr->pWStr);
int addWStrLen = wcslen(pWStr);
int allWStrLen = myWStrLen + addWStrLen + 1;
if (pMyWStr->memLen < allWStrLen)
{
pMyWStr->pWStr = (wchar_t *)realloc(pMyWStr->pWStr, allWStrLen * sizeof(wchar_t));
pMyWStr->memLen = allWStrLen;
}
wcscat(pMyWStr->pWStr, pWStr);
}
}char * myAStrAStr(MyAString * pMyAStr, char * pAStr)
{
if (NULL == pMyAStr || NULL == pMyAStr->pAStr || NULL == pAStr)
return NULL;
int pMyAStrLen = strlen(pMyAStr->pAStr);
int pAStrLen = strlen(pAStr);
int diffAStrLen = pMyAStrLen - pAStrLen;
for (int i = 0; i <= diffAStrLen; ++i)
{
int find = 1;
for (int j = 0; j < pAStrLen; ++j)
{
if (*(pMyAStr->pAStr + i + j) != *(pAStr + j))
{
find = 0;
break;
}
}
if (find)
{
return pMyAStr->pAStr + i;
}
}
return NULL;
}wchar_t * myWStrWStr(MyWString * pMyWStr, wchar_t * pWStr)
{
if (NULL == pMyWStr || NULL == pMyWStr->pWStr || NULL == pWStr)
return NULL;
wchar_t * pCopy = pMyWStr->pWStr;
while (*pCopy)
{
int find = 1;
wchar_t *pTmp = pCopy;
wchar_t *pTemp = pWStr;
while (*pTemp)
{
if ('\0' == *pTmp || *pTmp != *pTemp)
{
find = 0;
break;
}
++pTmp;
++pTemp;
}
if (find)
{
return pCopy;
}
++pCopy;
}
return NULL;
}void myAStrPrevInsertAStr(MyAString * pMyAStr, char * pAStr, char * pInsertAStr)
{
if (NULL == pMyAStr || NULL == pMyAStr->pAStr || NULL == pInsertAStr)
return;
char * pFind = myAStrAStr(pMyAStr, pAStr);
if (NULL == pFind)
return;
int myAStrLen = strlen(pMyAStr->pAStr);
int insertAStrLen = strlen(pInsertAStr);
int totalAStrLen = myAStrLen + insertAStrLen + 1;
int relativeLen = pFind - pMyAStr->pAStr;
if (pMyAStr->memLen < totalAStrLen)
{
pMyAStr->pAStr = (char *)realloc(pMyAStr->pAStr, totalAStrLen * sizeof(char));
pMyAStr->memLen = totalAStrLen;
}
for (int i = myAStrLen; i >= relativeLen; --i)
{
pMyAStr->pAStr[i + insertAStrLen] = pMyAStr->pAStr[i];
}
for (int i = relativeLen, j = 0; i < relativeLen + insertAStrLen; ++i)
{
pMyAStr->pAStr[i] = pInsertAStr[j++];
}
}void myWStrPrevInsertWStr(MyWString * pMyWStr, wchar_t * pWStr, wchar_t * pInsertWStr)
{
if (NULL == pMyWStr->pWStr || NULL == pInsertWStr)
return;
wchar_t * pFindWStr = wcsstr(pMyWStr->pWStr, pWStr);
if (NULL == pFindWStr)
return;
int myWStrLen = wcslen(pMyWStr->pWStr);
int insertWStrLen = wcslen(pInsertWStr);
int totalWStrLen = myWStrLen + insertWStrLen + 1;
if (pMyWStr->memLen < totalWStrLen)
{
pMyWStr->pWStr = (wchar_t *)realloc(pMyWStr->pWStr, totalWStrLen * sizeof(wchar_t));
pMyWStr->memLen = totalWStrLen;
}
pFindWStr = wcsstr(pMyWStr->pWStr, pWStr);
for (wchar_t * p = pMyWStr->pWStr + myWStrLen; p >= pFindWStr; --p)
{
*(p + insertWStrLen) = *p;
}
while (*pInsertWStr)
{
*pFindWStr++ = *pInsertWStr++;
}
}void myAStrNextInsertAStr(MyAString * pMyAStr, char * pAStr, char * pInsertAStr)
{
if (NULL == pMyAStr->pAStr || NULL == pInsertAStr)
return;
char * pFindAStr = strstr(pMyAStr->pAStr, pAStr);
if (NULL == pFindAStr)
return;
int myAStrLen = strlen(pMyAStr->pAStr);
int findAStrLen = strlen(pFindAStr);
int relAStrLen = myAStrLen - findAStrLen;
int insertAStrLen = strlen(pInsertAStr);
int totalAStrLen = myAStrLen + insertAStrLen + 1;
if (pMyAStr->memLen < totalAStrLen)
{
pMyAStr->pAStr = (char *)realloc(pMyAStr->pAStr, totalAStrLen * sizeof(char));
pMyAStr->memLen = totalAStrLen;
}
for (int i = myAStrLen; i >= relAStrLen + strlen(pAStr); --i)
{
*(pMyAStr->pAStr + i + insertAStrLen) = *(pMyAStr->pAStr + i);
}
for (int i = 0; i < insertAStrLen; ++i)
{
*(pMyAStr->pAStr + relAStrLen + strlen(pAStr) + i) = *(pInsertAStr + i);
}
}void myWStrNextInsertWStr(MyWString * pMyWStr, wchar_t * pWStr, wchar_t * pInsertWStr)
{
if (NULL == pMyWStr->pWStr || NULL == pInsertWStr)
return;
wchar_t * pFindWStr = wcsstr(pMyWStr->pWStr, pWStr);
if (NULL == pFindWStr)
return;
int myWStrLen = wcslen(pMyWStr->pWStr);
int insertWStrLen = wcslen(pInsertWStr);
int totalWStrLen = myWStrLen + insertWStrLen + 1;
if (pMyWStr->memLen < totalWStrLen)
{
pMyWStr->pWStr = (wchar_t *)realloc(pMyWStr->pWStr, totalWStrLen * sizeof(wchar_t));
pMyWStr->memLen = totalWStrLen;
}
pFindWStr = wcsstr(pMyWStr->pWStr, pWStr);
for (wchar_t * p = pMyWStr->pWStr + myWStrLen; p >= pFindWStr + wcslen(pWStr); --p)
{
*(p + insertWStrLen) = *p;
}
while (*pInsertWStr)
{
*(pFindWStr + wcslen(pWStr)) = *pInsertWStr++;
++pFindWStr;
}
}void myAStrDelFirstAStr(MyAString * pMyAStr, char * pAStr)
{
char * pFindAStr = strstr(pMyAStr->pAStr, pAStr);
if (NULL == pFindAStr)
return;
int delAStrLen = strlen(pAStr);
char * pRepAStr = pFindAStr + delAStrLen;
//while ('\0' != *pFindAStr)
//while (0 != pFindAStr)
//while (*pFindAStr)
//{
// *pFindAStr = *pRepAStr;
// ++pRepAStr;
// ++pFindAStr;
//}
//while (*pFindAStr++ = *pRepAStr++);
//while (*pFindAStr = *(pFindAStr + delAStrLen))
//{
// ++pFindAStr;
//}
while (*pFindAStr++ = *(pFindAStr + delAStrLen));
}void myWStrDelFirstWStr(MyWString * pMyWStr, wchar_t * pWStr)
{
wchar_t * pFindWStr = wcsstr(pMyWStr->pWStr, pWStr);
if (NULL == pFindWStr)
return;
int delWStrLen = wcslen(pWStr);
wchar_t * pRepWStr = pFindWStr + delWStrLen;
//while ('\0' != *pFindWStr);
//while (0 != *pFindWStr);
//while (*pFindWStr)
//{
// *pFindWStr = *pRepWStr;
// ++pRepWStr;
// ++pFindWStr;
//}
//while (*pFindWStr++ = *pRepWStr++);
//while (*pFindWStr = *(pFindWStr + delWStrLen))
//{
// ++pFindWStr;
//}
while (*pFindWStr++ = *(pFindWStr + delWStrLen));
}void myAStrDelAllAStr(MyAString * pMyAStr, char * pAStr)
{
char * pFindAStr = strstr(pMyAStr->pAStr, pAStr);
while (NULL != pFindAStr)
{
myAStrDelFirstAStr(pMyAStr, pAStr);
pFindAStr = strstr(pMyAStr->pAStr, pAStr);
}
}void myWStrDelAllWStr(MyWString * pMyWStr, wchar_t * pWStr)
{
wchar_t * pFindWStr = wcsstr(pMyWStr->pWStr, pWStr);
if (NULL != pFindWStr)
{
do
{
myWStrDelFirstWStr(pMyWStr, pWStr);
pFindWStr = wcsstr(pMyWStr->pWStr, pWStr);
} while (NULL != pFindWStr);
}
}void myAStrDelAllAStrByRec(MyAString * pMyAStr, char * pAStr)
{
if (NULL == strstr(pMyAStr->pAStr, pAStr))
return;
myAStrDelFirstAStr(pMyAStr, pAStr);
myAStrDelAllAStr(pMyAStr, pAStr);
}void myWStrDelAllWStrByRec(MyWString * pMyWStr, wchar_t * pWStr)
{
if (NULL == wcsstr(pMyWStr->pWStr, pWStr))
return;
myWStrDelFirstWStr(pMyWStr, pWStr);
myWStrDelAllWStrByRec(pMyWStr, pWStr);
}void myAStrRepFirstAStrLow(MyAString * pMyAStr, char * pAStr, char * pRepAStr)
{
char * pFindAStr = strstr(pMyAStr->pAStr, pAStr);
if (NULL == pFindAStr)
return;
myAStrPrevInsertAStr(pMyAStr, pAStr, pRepAStr);
myAStrDelFirstAStr(pMyAStr, pAStr);
}void myWStrRepFirstWStrLow(MyWString * pMyWStr, wchar_t * pWStr, wchar_t * pRepWStr)
{
wchar_t * pFindWStr = wcsstr(pMyWStr->pWStr, pWStr);
if (NULL == pFindWStr)
return;
myWStrPrevInsertWStr(pMyWStr, pWStr, pRepWStr);
myWStrDelFirstWStr(pMyWStr, pWStr);
}void myAStrRepAllAStrLow(MyAString * pMyAStr, char * pAStr, char * pRepAStr)
{
if (NULL == strstr(pMyAStr->pAStr, pAStr))
return;
myAStrRepFirstAStrLow(pMyAStr, pAStr, pRepAStr);
myAStrRepAllAStrLow(pMyAStr, pAStr, pRepAStr);
}void myWStrRepAllWStrLow(MyWString * pMyWStr, wchar_t * pWStr, wchar_t * pRepWStr)
{
if (NULL == wcsstr(pMyWStr->pWStr, pWStr))
return;
myWStrRepFirstWStrLow(pMyWStr, pWStr, pRepWStr);
myWStrRepAllWStrLow(pMyWStr, pWStr, pRepWStr);
}void myAStrRepFirstAStrHigh(MyAString * pMyAStr, char * pAStr, char * pRepAStr)
{
char * pFindAStr = strstr(pMyAStr->pAStr, pAStr);
if (NULL == pFindAStr)
return;
int pAStrLen = strlen(pAStr);
int pRepAStrLen = strlen(pRepAStr);
int allAStrLen = strlen(pMyAStr->pAStr) + 1 + (pRepAStrLen - pAStrLen);
if (pAStrLen < pRepAStrLen)
{
if (allAStrLen < pMyAStr->memLen)
{
pMyAStr->pAStr = (char *)realloc(pMyAStr->pAStr, allAStrLen*sizeof(char));
pMyAStr->memLen = allAStrLen;
}
pFindAStr = strstr(pMyAStr->pAStr, pAStr);
int addAStrLen = pRepAStrLen - pAStrLen;
for (char * p = pMyAStr->pAStr + strlen(pMyAStr->pAStr); p >= pFindAStr + pAStrLen; --p)
{
*(p + addAStrLen) = *p;
}
while (*pRepAStr)
{
*pFindAStr++ = *pRepAStr;
++pRepAStr;
}
}
else if (pAStrLen == pRepAStrLen)
{
while (*pRepAStr)
{
*pFindAStr++ = *pRepAStr++;
}
}
else
{
int subAStrLen = pRepAStrLen - pAStrLen;
while (*pRepAStr)
{
*pFindAStr++ = *pRepAStr++;
}
char * pTemp = pFindAStr + pAStrLen;
while (*pTemp++ = *(pTemp + subAStrLen));
}
}void myAStrRepAllAStrHigh(MyAString * pMyAStr, char * pAStr, char * pRepAStr)
{
if (NULL == strstr(pMyAStr->pAStr, pAStr))
return;
myAStrRepFirstAStrHigh(pMyAStr, pAStr, pRepAStr);
myAStrRepAllAStrHigh(pMyAStr, pAStr, pRepAStr);
}void myWStrRepFirstWStrHigh(MyWString * pMyWStr, wchar_t * pWStr, wchar_t * pRepWStr)
{
wchar_t * pFindWStr = wcsstr(pMyWStr->pWStr, pWStr);
if (NULL == pFindWStr)
return;
int pWStrLen = wcslen(pWStr);
int pRepWStrLen = wcslen(pRepWStr);
if (pWStrLen < pRepWStrLen)
{
int totalWStrLen = wcslen(pMyWStr->pWStr) + (pRepWStrLen - pWStrLen) + 1;
if (pMyWStr->memLen < totalWStrLen)
{
pMyWStr->pWStr = (wchar_t *)realloc(pMyWStr->pWStr, totalWStrLen * sizeof(wchar_t));
pMyWStr->memLen = totalWStrLen;
}
pFindWStr = wcsstr(pMyWStr->pWStr, pWStr);
int myWStrLen = wcslen(pMyWStr->pWStr);
int moveWStrLen = pRepWStrLen - pWStrLen;
for (wchar_t * p = pMyWStr->pWStr + myWStrLen; p >= pFindWStr + pWStrLen; --p)
{
*(p + moveWStrLen) = *p;
}
while (*pRepWStr)
{
*pFindWStr++ = *pRepWStr++;
}
}
else if (pWStrLen == pRepWStr)
{
while (*pRepWStr)
{
*pFindWStr++ = *pRepWStr++;
}
}
else
{
int moveWStrLen = pWStrLen - pRepWStrLen;
wchar_t * p = pFindWStr + pWStrLen - moveWStrLen;
while (*p++ = *(p + moveWStrLen));
while (*pRepWStr)
{
*pFindWStr++ = *pRepWStr++;
}
}
}void myWStrRepAllWStrHigh(MyWString * pMyWStr, wchar_t * pWStr, wchar_t * pRepWStr)
{
if (NULL == wcsstr(pMyWStr->pWStr, pWStr))
return;
myWStrRepFirstWStrHigh(pMyWStr, pWStr, pRepWStr);
myWStrRepAllWStrHigh(pMyWStr, pWStr, pRepWStr);
}

///main.c
#define _CRT_SECURE_NO_WARNINGS
#include "MyString.h"
#include <locale.h>
#include <stdio.h>int main(void)
{
setlocale(LC_ALL, "zh-CN");
MyAString myAString;
MyWString myWString;
initMyAStrWithAStr(&myAString, "ABC123321CBA123");
initMyWStrWithWStr(&myWString, L"ABC123321CBA123");
myAStrAddAStr(&myAString,"HaHaHa嘻嘻嘻");
myWStrAddWStr(&myWString, L"XiXiXi哈哈哈");
//myAStrPrevInsertAStr(&myAString, "123", "JKL");
//myAStrNextInsertAStr(&myAString, "123", "JKL");
//myWStrPrevInsertWStr(&myWString, L"123", L"JKL");
//myWStrNextInsertWStr(&myWString, L"123", L"JKL");
//myAStrDelFirstAStr(&myAString, "ABC");
//myWStrDelFirstWStr(&myWString, L"ABC");
//myAStrDelAllAStr(&myAString, "123");
//myWStrDelAllWStr(&myWString, L"123");
//myAStrDelAllAStrByRec(&myAString, "123");
//myWStrDelAllWStrByRec(&myWString, L"123");
//myAStrRepFirstAStrLow(&myAString, "123", "JKL");
//myWStrRepFirstWStrLow(&myWString, L"123", L"JKL");
//myAStrRepAllAStrLow(&myAString, "123", "JKL");
//myWStrRepAllWStrLow(&myWString, L"123", L"JKL");
//myAStrRepFirstAStrHigh(&myAString, "123", "JKL");
//myAStrRepAllAStrHigh(&myAString, "123", "JKL");
//myWStrRepFirstWStrHigh(&myWString, L"123", L"JKL");
//myWStrRepAllWStrHigh(&myWString, L"123", L"JKL");
showMyAStr(&myAString);
showMyWStr(&myWString);
//printf("%s \n", myAStrAStr(&myAString, "123321"));
//wprintf(L"%ws \n", myWStrWStr(&myWString, L"123321")); system("pause");
}

程序片段(03):myarray.h+myarray.c+main.c

内容概要:数组库

///myarray.h
#pragma once//1.包括的时候,仅仅包括一次[预编译的时候]
#include <stdio.h>
#include <stdlib.h>
#include <memory.h>
#define datatype int//2.double ,char-X->int * struct[扩展的时候,仅仅能扩展基本数据类型]struct array
{//3.[採用结构体进行数组模拟]
datatype *pstart;//数组首地址
int length;//长度[数组]
int sortstat;//有序或者无序,0无序,1有序
};struct Res
{//4.[採用结构体模拟字符串类型的数组,因为字符串数组其中的每一个元素存储的是字符串地址,所以採用二级指针进行该数组的模拟动作]
datatype **ppstat;//创建指针数组[二级指针(一级指针地址)-->一级指针(变量地址)-->零级指针(数据)]
int n;
};//5.[为结构体模拟数组创建一些针对于该数组的操作函数]
//[初始化]
void init(struct array *parr);
void initwithdata(struct array *parr, datatype data);
void initwitharray(struct array *parr, datatype *pdata, int datalength);//[添加]
void addobject(struct array *parr, datatype data);
void addobjects(struct array *parr, datatype *pdata, int datalength);//[插入]
void insertobject(struct array *parr, datatype data, datatype insertdata);//依据位置插入
void insertobjects(struct array *parr, datatype data, datatype *pdata, int datalength);//[删除]
void deletefirstobject(struct array *parr, datatype data);
void deleteallobject(struct array *parr, datatype);//[改动]
void changefirstobject(struct array *parr, datatype data, datatype newdata);
void changeallobject(struct array *parr, datatype data, datatype newdata);//[查询]
datatype * findfirst(struct array *parr, datatype data);//查找
struct Res findall(struct array *parr, datatype data);//查找全部//[显示]
void show(struct array *parr);//5.数组库扩展功能实现
// (1)排序:选择,插入,二分插入,冒泡,堆,高速,从左之右
// (2)插值查找,二分查找
// (3)初始化with可变參数

///myarray.c
#include "myarray.h"void init(struct array *parr)
{//1.[初始化数据结构]
if (parr != NULL)
{
parr->pstart = NULL;
parr->length = 0;
parr->sortstat = 0;
}
else
{
printf("init error!");
}
}void initwithdata(struct array *parr, datatype data)
{//2[.初始化结构体数据(单个)]
if (parr != NULL)
{
parr->pstart = malloc(sizeof(datatype));
*(parr->pstart) = data;//初始化
parr->length = 1;
parr->sortstat = 0;
}
else
{
printf("initwithdata error!");
}
}void initwitharray(struct array *parr, datatype *pdata, int datalength)
{//3.[初始化结构体数据(多个)]
if (parr != NULL)
{
parr->pstart = malloc(sizeof(datatype)*datalength);
memcpy(parr->pstart, pdata, sizeof(datatype)*datalength);
parr->length = datalength;
parr->sortstat = 0;
}
else
{
printf("initwitharray error!");
}
}void addobject(struct array *parr, datatype data)
{
if (parr != NULL)
{//4.该结构体模拟的数组存在
if (parr->pstart == NULL || parr->length == 0)
{//5.该数组的状态处于初始化状态
initwithdata(parr, data);
}
else
{
//6.数组操作说明:5 a[4]-->[5个元素-->最后一个元素为a[4]-->5这个索引为数组外尾第一个元素]
parr->pstart = realloc(parr->pstart, (parr->length + 1)*sizeof(datatype));//拓展内存
parr->pstart[parr->length] = data;//插入
parr->length += 1;//长度自增
}
}
else
{
printf("addobject error!");
}
}void addobjects(struct array *parr, datatype *pdata, int datalength)
{
if (parr != NULL)
{
if (parr->pstart == NULL || parr->length == 0)
{
initwitharray(parr, pdata, datalength);//调用初始化
}
else
{
//7.说明:12345 a[4] &a[5]
parr->pstart = realloc(parr->pstart, (parr->length + datalength)*sizeof(datatype));//拓展内存
memcpy(parr->pstart + parr->length, pdata, datalength*sizeof(datatype));//8.追加一个数组的时候,能够指定位置进行追加动作,假设是追加多个数据,建议採用内存拷贝机制,提升效率
parr->length += datalength;//长度自增
}
}
else
{
printf("addobjects error!");
}
}void insertobject(struct array *parr, datatype data, datatype insertdata)
{
if (parr != NULL)
{
datatype *pfind = findfirst(parr, data);
if (pfind == NULL)
{
printf("can not insertobject error!");
}
else
{
int curr = pfind - parr->pstart;//9.指针相减确定相对下标,当前数据的相对下标
//printf("\n curr=%d", curr);//10.同类型的指针相减,自己主动除以该指针所指向的变量类型长度
parr->pstart = realloc(parr->pstart, (parr->length + 1)*sizeof(datatype));//拓展内存
for (int i = parr->length - 1; i >= curr; i--)//11.减一的目的是为了从最后一个元素開始进行数据的拖动
{
parr->pstart[i + 1] = parr->pstart[i];//往后拖动
}
parr->pstart[curr] = insertdata;//插入数据
parr->length += 1;//长度自增
}
}
else
{
printf("insertobject error!");
}
}void insertobjects(struct array *parr, datatype data, datatype *pdata, int datalength)
{
if (parr != NULL)
{
datatype *pfind = findfirst(parr, data);
if (pfind == NULL)
{
printf("can not insertobject error!");
}
else
{
int curr = pfind - parr->pstart;
parr->pstart = realloc(parr->pstart, (parr->length + datalength)*sizeof(datatype));
for (int i = parr->length - 1; i >= curr; i--)
{
parr->pstart[i + datalength] = parr->pstart[i];
}
memcpy(parr->pstart + curr, pdata, datalength*sizeof(datatype));//拷贝数组
parr->length += datalength;//改动长度
}
}
else
{
printf("insertobjects error!");
}
}void deletefirstobject(struct array *parr, datatype data)
{
if (parr!=NULL)
{
datatype *pfind = findfirst(parr, data);
if (pfind==NULL)
{
printf("can not find deleteerror!");
}
else
{
int curr = pfind - parr->pstart;//指针相减确定下标,当前数据的相对下标
for (int i = curr; i < parr->length - 1; i++)
{
parr->pstart[i] = parr->pstart[i + 1];//删除,从后向前移动
}
parr->length -= 1;//长度自减
parr->pstart = realloc(parr->pstart, (parr->length)*sizeof(datatype));//压缩内存
}
}
else
{
printf("deleteobject error!");
}
}void deleteallobject(struct array *parr, datatype data)
{
if (parr!=NULL)
{
for (int *pcurr = findfirst(parr, data); pcurr != NULL; pcurr = findfirst(parr, data))
{
deletefirstobject(parr, data);
}
}
else
{
printf("deleteobject error!");
}
}void changefirstobject(struct array *parr, datatype data, datatype newdata)
{
if (parr != NULL)
{
datatype *pfind = findfirst(parr, data);
if (pfind == NULL)
{
printf("can not find changeobject error!");
}
else
{
*pfind = newdata;
}
}
else
{
printf("deleteobject error");
}
}void changeallobject(struct array *parr, datatype data, datatype newdata)
{
if (parr!=NULL)
{
for (int *pcurr = findfirst(parr, data); pcurr != NULL; pcurr = findfirst(parr, data))
{
changefirstobject(parr, data, newdata);
}
}
else
{
printf("changeallobject error");
}
}datatype * findfirst(struct array *parr, datatype data)
{
if (parr == NULL || parr->pstart == NULL || parr->length == 0)
{
printf("没有数据咋查找?");
return NULL;
}
else
{
//5 0-4
datatype *pfind = NULL;
for (int i = 0; i < parr->length; i++)
{
if (data == parr->pstart[i])
{
pfind = parr->pstart[i];//parr->pstart+i
break;
}
}
return pfind;
}
}struct Res findall(struct array *parr, datatype data)
{
struct Res ResA;
ResA.n = 0;//统计元素个数
for (int i = 0; i < parr->length; i++)
{
if (data==parr->pstart[i])//基本完毕
{
ResA.n++;
}
}
ResA.ppstat = malloc(sizeof(datatype *)*ResA.n);//分配内存[指针数组占用]
int j = 0;//代表下标
for (int i = 0; i < parr->length; i++)
{
if (data==parr->pstart[i])
{
ResA.ppstat[j++] = parr->pstart + i;//保存地址
}
} return ResA;
}void show(struct array *parr)
{
if (parr == NULL || parr->pstart == NULL || parr->length == 0)
{
printf("没有数据咋显示?");
return;
}
else
{
//5 0-4
printf("\n数组此时状态\n");
for (int i = 0; i < parr->length; i++)
{
printf("%4d", parr->pstart[i]);//打印数据
}
}
}

///main.c
#include "myarray.h"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.ppstat[i], *res.ppstat[i]);
} show(&mydata); system("pause");
}