本文由 发布，转载请注明出处，如有问题请联系我们！ 发布时间: 2021-08-01c语言字符串输入函数-c语言函数大全及详解

c语言字符串数组实际操作在招聘面试中很普遍。一起来看看对你有没有协助！

为了更好地完成这一逻辑性，根据strlen获得字符串数组的长短，随后根据len/2交叉式取值。这儿必须特别注意的是，不用考虑到len是质数或是双数。

假如len是单数，最终一个字符不用翻转；假如len是一个双数，那麼最终2个标识符是反过来的。

#包含“stdio.h”

void rechange_str(char *str)

{

int i，len

char tmp

if(NULL = = str){ 0

回到；

}

len = strlen(str)；

for(I = 0；I < len/2；i ){ 0

tmp = str[I]；

str[I]= str[len-I-1]；

str[len-I-1]= tmp；

}

}

int main(空)

{

char str[20] =“您好，全球”；

printf("%sn "，str)；

rechange_str(字符串数组)；

printf("%sn "，str)；

return(0)；

}

程序流程輸出

您好，全球

dlrow，olleh

——————————–

0.02841秒后过程撤出，传参0

按照任意键再次。

整数金额到字符串数组

要完成逻辑性，看每一个整数金额的变换管理体系，根据%计算加/计算获得从位到一百位，随后用一个字符数组储存0-F。

将一位数相匹配的值变换为标识符，留意字符串数组的翻转，考虑到如何处理传到的负值，随后根据旋转字符串数组进行这个实际操作。

下边的编码必须细心科学研究，因此最好是自身运作。

#包含“stdio.h”

char *sky_itoa(int值，char *str，无符号整数数量)

{

char list[]= " 0123456789 ABCDEF "；

无标记int tmp _ value

int i，j，k；

if(NULL = = str){ 0

回到空值；

}

假如(2！=数量&& 8！=数量&& 10！=数量&& 16！=数量){ 0

回到空值；

}

I = 0；

k = 0；

if(数量= = 10 & & value < 0){ 0

tmp_value =(无符号整数)(0–值)；

str[i ]= '-'；

k = 1；

} else {

tmp_value =(无符号整数)值；

}

做{

str[i ]= list[tmp _ value % radix]；

tmp_value /=数量；

} while(tmp _ value)；

str[I]= ' '；

//旋转。

char tmp

for(j = k；j <(I k)/2；j ){ 0

tmp = str[j]；

str[j]= str[I k-j-1]；

str[I k-j-1]= tmp；

}

回到字符串数组；

}

int main(空)

{

int a = 1254545

char strwhile (*str！= '') {= { 0 }；

printf("%sn "，sky_itoa(a，str，2))；

printf("%sn "，sky_itoa(a，str，8))；

printf("%sn "，sky_itoa(a，str，10))；

printf("%sn "，sky_itoa(a，str，16))；

return(0)；

}

程序流程輸出

100110010010010010001

4622221

1254545

132491

——————————–

0.02963秒后过程撤出，传参0

按照任意键再次。

字符串数组拷贝

完成逻辑性，逐一取值，直至“”终止。

#包含“stdio.h”

char *sky_strcpy(char *dst，const char *str)

{

if(NULL = = dst | | NULL = = str){ 0

回到空值；

}

char * ret = dst

[100]

* dst = * str ；

}

回到ret

}

int main(空)

{

char str_1[100] =“您好，全球”；

char str[100]= { 0 }；

sky_strcpy(str，str _ 1)；

printf("str_1:%sn "，str _ 1)；

printf("str:%sn "，str)；

return(0)；

}

程序流程輸出

您好，全球

您好，全球

——————————–

0.03334秒后过程撤出，传参0

按照任意键再次。

字符串比较

1.一切正常较为是一样的逻辑性，分辨数组长度是不是同样，假如同样，逐一较为标识符是不是同样。

#包含“stdio.h”

int sky_strcmp(char *dst，char *str)

{

int i，len

if(NULL = = dst | | NULL = = str){ 0

回到0；

}

if (strlen(dst)！= strlen(str)){ 0

回到0；

}

len = strlen(dst)；

for(I = 0；i < leni ){ 0

if (*dst ！= * str ){ 0

回到0；

}

}

回到1；

}

int main(空)

{

char str_1[100] =“您好，全球”；

char str_2[100] =“您好，全球”；

char str[100]=“adfs”；

printf("%dn "，sky_strcmp(str_1，str))；

printf("%dn "，sky_strcmp(str_1，str _ 2))；

return(0)；

}

程序流程輸出

0

一个

——————————–

0.02802秒后过程撤出，传参0

按照任意键再次。

2.忽视英文大小写字符串比较。

完成逻辑性，在较为标识符的情况下，能够统一转化成英文大写还是小写字母，随后开展较为，和常规的非常沒有差别。

#包含“stdio.h”

#界定CONVERT(c)(((c)> = ' A ' & &(c)int sky _ strcmp(char * dst，char *str)

{

int i，len

if(NULL = = dst | | NULL = = str){ 0

回到0；

}

if (strlen(dst)！= strlen(str)){ 0

回到0；

}

len = strlen(dst)；

for(I = 0；i < leni ){ 0

if (CONVERT(*dst)！= CONVERT(* str)){ 0

回到0；

}

dst ；

str ；

}

回到1；

}

int main(空)

{

char str _ 1[100]=“HellO，world”；

char str_2[100] =“您好，全球”；

char str[100]=“adfs”；

printf("%dn "，sky_strcmp(str_1，str))；

printf("%dn "，sky_strcmp(str_1，str _ 2))；

return(0)；

}

程序流程輸出

0

一个

——————————–

0.04624秒后过程撤出，传参0

按照任意键再次。

Memcpy涵数完成

逻辑性的完成主要是根据逐一取值来实现的。

1.沒有考虑到团本遮盖的难题。

#包含“stdio.h”

#包括“string.h”

void *sky_memecpy(void *dst，const void *str，int n)

{

if (NULL == dst || NULL == str || n回到NULL；

}

char * pdst =(char *)dst；

char *pstr = (char *)字符串数组；

while(n–){ 0

* pdst = * pstr ；

}

回到dst

}

int main(空)

{

char str _ 1[100]=“HellO，world”；

char str _ 2[100]= " sdfsdfs "；

sky_memecpy(str_2，str_1，strlen(str _ 1))；

printf("%sn "，str _ 2)；

return(0)；

}

程序流程輸出

heLlo，world

——————————–

0.02516秒后过程撤出，传参0

按照任意键再次。

2.考虑到复制遮盖的难题。

拷贝是大家拷贝字符串数组时必须特别注意的难题。在我下面的实例程序流程中，当应用第一个涵数时，有什么问题，可是当应用第二个涵数时，没有问题。

缘故是咱们的源字符串数组和总体目标字符串数组的地点是同样的，大家想将字符串数组向后挪动一个部位，但事实上有一个难题。

#包含“stdio.h”

#包括“string.h”

void *sky_memecpy_1(void *dst，const void *str，int n)

{

if (NULL == dst || NULL == str || n回到NULL；

}

char * pdst =(char *)dst；

char *pstr = (char *)字符串数组；

while(n–){ 0

* pdst = * pstr ；

}

回到dst

}

void *sky_memecpy(void *dst，const void *str，int n)

{

if (NULL == dst || NULL == str || n回到NULL；

}

char * pdst =(char *)dst；

char *pstr = (char *)字符串数组；

if(pdst > pstn & & pdst < pstn n){ 0

pdst = pdst n–1；

pstr = pstr n–1；

while(n–){ 0

* pdst –= * pstr –;

}

} else {

while(n–){ 0

* pdst = * pstr ；

}

}

回到dst

}

int main(空)

{

char str _ 1[100]=“HellO，world”；

char str _ 2[100]=“HellO，world”；

sky_memecpy_1(str_1 1，str_1，strlen(str _ 1))；

printf("%sn "，str _ 1)；

sky_memecpy(str_2 1，str_2，strlen(str _ 2))；

printf("%sn "，str _ 2)；

return(0)；

}

程序流程輸出

邪恶漫画

全球，您好

——————————–

0.02773秒后过程撤出，传参0

按照任意键再次。

对于以上拷贝遮盖难题，独立撰写了一个测试代码。

#包含“stdio.h”

#包括“string.h”

void *sky_memecpy(void *dst，const void *str，int n)

{

if (NULL == dst || NULL == str || n回到NULL；

}

char * pdst =(char *)dst；

char *pstr = (char *)字符串数组；

while(n–){ 0

printf("dst:%c—>str:%cn "，*pdst，* pstr)；

* pdst = * pstr ；

}

回到dst

}

int main(空)

{

char str _ 1[100]=“HellO，world”；

sky_memecpy(str_1 1，str_1，strlen(str _ 1))；

printf("%sn "，str _ 1)；

return(0)；

}

程序流程輸出

dst:e—>str:h

钻具检测:左—>钻具检测:高

dst:l—>str:h

dst:o—>str:h

dst:，—>str:h

dst:w—>str:h

dst:o—>str:h

dst:r—>str:h

dst:l—>str:h

dst:d—>str:h

dst: —>str:h

邪恶漫画

——————————–

0.02575秒后过程撤出，传参0

按照任意键再次。

逐渐时，dst偏向e标识符，str偏向h标识符，随后dst先挪动，每一次str再挪动，因此dst被h标识符遮盖。