#字符串倒序输出

实现逻辑，通过strlen获取字符串长度，然后通过 len/2 进行交叉赋值，这里需要注意，不需要考虑len是奇数还是偶数的问题。

如果len是奇数，最后一个字符就不需要倒序，如果是偶数，最后两个字符就倒序。

#include "stdio.h"
1 ^4 ~/ W$ D, U& b3 z: _
3 r3 n6 L, }* R* }void rechange_str(char *str)
{
5 a( L$ \- P' J int i, len;
5 G* [7 V/ u3 c; y$ ~# ` char tmp;
if (NULL == str) {
  return ;
$ K0 Y6 d0 ~# u* e/ s, M }
. @+ V2 ~) }& g6 e len = strlen(str);
7 ]+ m6 c% X4 t; w( ^4 i4 {6 q for (i = 0; i < len/2; i ++) {
" ^4 O, Y0 r' F2 X* {5 z0 K  tmp = str;
% s3 L$ ]7 Y$ b# h% Z" s0 z. `  str = str[len-i-1];
  str[len-i-1] = tmp;
}
) n& p! n; L  F' Z}
: {. t: L4 o  M7 s# Q3 F
0 n+ Y% ^& @0 y8 n$ T" eint main(void)
/ ^& R* _2 f2 z2 o{
char str[20] = "hello,world";
printf("%s\n",str);
: w6 s, E' h$ {( D/ P rechange_str(str);
printf("%s\n",str);
return (0);
}
) Z- v3 T. q: p- D+ S6 t

程序输出

hello,world
dlrow,olleh

--------------------------------
5 s( _# d* \' ~" Y0 B( t. |Process exited after 0.02841 seconds with return value 0
请按任意键继续. . .
#整型转字符串

实现逻辑，每个整数看其转换进制，从个位到十位百位都可以通过%操作加上/操作获得，再用一个字符数组保存0-F。

用个位数对应值转为字符，注意转换出的字符串是反向的,还要考虑传入的若是负数如何处理，再用翻转字符串完成最后整个操作

下面这段代码需要好好研究一下，最好自己运行试试。

#include "stdio.h"

' @! e7 J, L; `0 Q( nchar *sky_itoa(int value, char *str, unsigned int radix)
, [0 ?+ @: z/ k{
char list[] = "0123456789ABCDEF";
$ S6 g$ @' d; Z# D: F8 B9 I6 h9 @ unsigned int tmp_value;
int i, j, k;
# A/ m) i! T0 _# B" A if (NULL == str) {
* g" {( p9 T1 d+ d, B$ g8 C  return NULL;
}
if (2 != radix && 8 != radix && 10 != radix && 16 != radix) {
2 K. ^4 d; O: i. |! l  g  return NULL;
}
i = 0;
k = 0;
if (radix == 10 && value < 0) {
: v1 [$ V- B3 g+ n, T' v6 t  tmp_value = (unsigned int)(0 - value);
  _- h0 u& ~! O- `. f6 b3 v9 O  str[i++] = '-';
! g5 o' c' v7 t9 g  k = 1;
} else {
! l5 D8 s8 P! {! B+ H+ _) w  tmp_value = (unsigned int)value;
}
0 A+ v0 u3 C( R% E do {
  str[i++] = list[tmp_value%radix];
  tmp_value /= radix;
+ B" x2 `) t. ~, i  d } while(tmp_value);
! O2 y0 J$ {9 H6 a8 o+ g9 V$ P str = '\0';
//翻转
char tmp;
for (j = k; j < (i+k)/2; j++) {
  tmp = str[j];
  str[j] = str[i+k-j-1];
  str[i+k-j-1] = tmp;
+ p% e, F1 f. O% \/ I7 @ }
5 T) n7 [7 T% S1 T. {+ X7 E3 G return str;
}

! k0 J, @" a) l7 a, W7 @' wint main(void)
1 k$ g+ g  a  o7 `2 M2 O7 W2 l4 s{
int a = 1254545;
; x9 }6 N5 \& M- U- l! I9 a char str[100] ={0};
, L  B/ W. A: ^7 E7 ?& G, N
printf("%s\n",sky_itoa(a,str,2));
printf("%s\n",sky_itoa(a,str,8));
$ g- |( T1 f& V6 q( v printf("%s\n",sky_itoa(a,str,10));
! c$ T0 R4 J4 h4 [ printf("%s\n",sky_itoa(a,str,16));
+ V* P* E0 ^1 m+ j# ] return (0);
}

程序输出

100110010010010010001
) V2 [- W0 U2 C. {( ^4622221
" A. }) S$ ~5 L. p, ]# `1254545
9 f0 Z* e) _# p7 Y132491

) x9 m3 }' Z# S4 m( T- m--------------------------------
0 E8 L6 R/ p) k& y# @, uProcess exited after 0.02963 seconds with return value 0
- J  Y5 g! m! V: E5 r( ?4 z* v请按任意键继续. . .
#字符串复制

实现逻辑，逐个赋值直到遇到'\0'停止即可

#include "stdio.h"
6 g4 N* L" |$ [& K" m
7 y- u  i3 ?% P/ I7 R' ?5 F6 S+ ?) Jchar *sky_strcpy(char *dst, const char *str)
{
if (NULL == dst ||  NULL == str) {
" j$ \$ S4 x" ~  return NULL;
/ e* X5 E/ m: n! j3 k$ H1 N }
char *ret = dst;
0 E, W9 Z# M- G0 n. K4 b$ Y# x while (*str != '\0') {
2 v+ m% U1 @+ |4 b  *dst ++ = *str ++;
7 m' m, C( p5 m+ [% F }
return ret;
: u3 b$ U, s: k0 k  c1 \}

int main(void)
{
, F$ R1 H6 G( s/ ~$ B8 i: J# L+ A char str_1[100] = "hello,world";
# c7 J9 {) i( R1 z! }3 p5 z char str[100] ={0};

8 U: j7 B5 n8 ^/ n( ? sky_strcpy(str,str_1);
printf("str_1:%s\n",str_1);
printf("str:%s\n",str);
return (0);
  K4 i$ V0 s  \5 Z2 o8 {}

程序输出

str_1:hello,world
str:hello,world

, C( }" a0 E2 a' }--------------------------------
Process exited after 0.03334 seconds with return value 0
请按任意键继续. . .
( x9 h! d  A, i* _& e#字符串比较

1、正常比较是否相同 实现逻辑，判断字符串长度是否相同，若相同逐个比较字符是否相同

#include "stdio.h"
$ ?( m! P( r# H+ J
& n% Y2 L1 I( q8 c  L: o- ]int sky_strcmp(char *dst, char *str)
{
7 D( ]+ Y) a# p  J/ z0 D) P int i, len;
if (NULL == dst || NULL == str) {
  return 0;
}
# s# \! c& ]4 |/ @( j# ]/ R if (strlen(dst) != strlen(str)) {
! r/ ~( ]3 i% g4 q. b6 X. Z0 {  return 0;
}
2 {  t. `4 ^( L3 U len = strlen(dst);
for (i = 0; i < len; i++) {
  if (*dst++ != *str++) {
* }9 q, K6 E3 Z: ~   return 0;
) h  G: a! j$ M  }
" I9 L# R0 M7 P  l }
return 1;
- d, d" R/ `! S3 W" }. S}
% ^8 g3 \- ?4 @7 e% N
1 l, o6 S9 Z. Q, t) p, q9 c; @int main(void)
# d4 Q  X1 G* d& }$ Y& R6 _{
$ i' z3 E, S4 |7 ^ char str_1[100] = "hello,world";
char str_2[100] = "hello,world";
4 i% Z& q% d9 A! [5 A char str[100] = "adfs";
+ e# [$ \0 O5 N  W3 \2 X+ {
printf("%d\n",sky_strcmp(str_1,str));
printf("%d\n",sky_strcmp(str_1,str_2));
return (0);
}
' A" D: `) |0 b0 m/ K

程序输出

0
1

--------------------------------
: L: G& H2 Z" P2 Z; UProcess exited after 0.02802 seconds with return value 0
请按任意键继续. . .
) A- D0 c% J0 m8 S; W9 \

2、忽略大小写字符串比较

实现逻辑，在比较字符时可以将其统一转换为大写或小写，然后再进行比对即可，和正常对比无其他不同

#include "stdio.h"
2 l4 j0 R- B! t( c* Q
#define CONVERT(c) (((c) >= 'A' && (c) <= 'Z') ? ((c) - 'A' + 'a') : (c))
& d; y! U, _- p. ^" g int sky_strcmp(char *dst, char *str)
{
* s/ C, Y2 u! k3 k; x, \  D* |  int i, len;
5 h. l% v1 K/ R  if (NULL == dst || NULL == str) {
   return 0;
  }
4 A' o5 G/ L6 ^" L+ _1 B9 O  if (strlen(dst) != strlen(str)) {
) |/ C! m- m8 H5 O: x9 d% t* l   return 0;
  }
7 a5 M# A& P: E5 j9 Y# p  len = strlen(dst);
  for (i = 0; i < len; i++) {
   if (CONVERT(*dst) != CONVERT(*str)) {
    return 0;
- ^6 E+ M) Z1 E9 Q   }
   dst ++;
2 o7 G  [+ Y! o+ V/ x8 x# W: k  G   str ++;
, x! s( n" m% p1 N7 |7 }. V5 _/ r  }
  return 1;
$ L* g' \) O# w. Y' D5 ~ }
' _! L- t; w/ Q* O6 }, r4 e
+ K5 G. \$ k) J: A1 e* [& h int main(void)
: m2 x* V2 c! X8 a$ G {
  char str_1[100] = "heLlo,world";
- [2 l$ }. x( O8 B  char str_2[100] = "hello,world";
  char str[100] = "adfs";
( R2 }. {7 J7 h4 r  
  printf("%d\n",sky_strcmp(str_1,str));
; E8 J4 v6 C0 B% m3 U! n/ J4 {) ?  printf("%d\n",sky_strcmp(str_1,str_2));
  return (0);
) y) Q4 p. p; |; t* \ }
7 i. o+ u5 x! M* u, G7 i, D

程序输出

0
1
/ Q9 M0 `0 o- U7 y3 E, e7 F0 R
--------------------------------
2 C+ W, s" T' |/ b" T6 q1 t' u  BProcess exited after 0.04624 seconds with return value 0
9 w1 k& J/ y% d6 H. M1 q请按任意键继续. . .
#memcpy函数实现

实现逻辑，主要就是逐个赋值即可完成

1、不考虑拷贝覆盖问题

#include "stdio.h"
#include "string.h"

  J- T. @8 _- |* g( Vvoid *sky_memecpy(void *dst, const void *str, int n)
' L# Y$ r, e; Q/ F0 B& h: R{
! r& a6 D0 b$ h! A) k; J+ _, M+ a2 E1 n if (NULL == dst || NULL == str || n <= 0) {
  return NULL;
}
char *pdst = (char *)dst;
char *pstr = (char *)str;
while (n --) {
  *pdst ++ = *pstr ++;
3 _* _5 J! R3 y, I! u; f( g1 V6 f3 R }
return dst;
}
) b0 y% ^% d) r  i0 w; ~
* Q; R3 \- I; Gint main(void)
+ T% ~' W# f# ?2 v{
char str_1[100] = "heLlo,world";
char str_2[100] = "sdfsdfs";
. v2 i4 U) p% q; ^% q+ _. X sky_memecpy(str_2,str_1,strlen(str_1));
printf("%s\n",str_2);
1 Y) U  J: B2 r- b4 w return (0);
}

程序输出

heLlo,world

--------------------------------
Process exited after 0.02516 seconds with return value 0
* e+ M, A5 I! x! x) ]2 s: U请按任意键继续. . .

2、考虑拷贝覆盖问题

拷贝覆盖是我们在拷贝字符串的时候需要注意的一个问题，我下面的示例程序，使用第一个函数的时候，就出现了问题，使用第二个函数就没有出现问题。

原因是，我们源字符串和目的字符串的地址都是一样的，我们希望把字符串往后移动一个位置，但是实际上出现了问题。

#include "stdio.h"
9 r" [+ @1 C0 d- F" B5 x #include "string.h"

. g5 `  w0 J+ e; \6 M void *sky_memecpy_1(void *dst, const void *str, int n)
. z5 B! e0 j5 J% K {
  H" \* v* s+ b$ U% y  if (NULL == dst || NULL == str || n <= 0) {
& ^; O5 |1 C: Y. `   return NULL;
  }
  char *pdst = (char *)dst;
7 K8 @4 |* Z, b4 y, u  char *pstr = (char *)str;
  while (n --) {
   *pdst ++ = *pstr ++;
7 w) U5 v- X/ H! S9 E  }
8 b- D  z, t# ~$ B/ y8 n  return dst;
}

' c+ [! u6 b8 l/ F; d. d void *sky_memecpy(void *dst, const void *str, int n)
{
: l5 J5 |0 ^6 L; R) F8 |6 p& F  if (NULL == dst || NULL == str || n <= 0) {
   return NULL;
  }
* @, i; O9 `5 h6 ]6 z  char *pdst = (char *)dst;
  char *pstr = (char *)str;
   
3 g# F5 Z( k! t: _: u  U! W3 N  if (pdst > pstr && pdst < pstr + n) {
- x# E. _  y. ^+ f6 f( [   pdst = pdst + n - 1;
   pstr = pstr + n - 1;
3 a- i4 ^: y6 t0 E   while (n --) {
2 g  u) F$ h% |8 ]# i& g" Q    *pdst -- = *pstr --;
0 q. B; Z/ f$ E. \7 p   }
  } else {
2 b% A" i' G  x4 [6 S- B6 @: M   while (n --) {
    *pdst ++ = *pstr ++;
   }
% h% V3 w$ T) J6 w* u. d1 z  }
5 E) X6 H6 a; E8 Y# r6 F  return dst;
}
2 f8 u2 d3 `% v7 m# W" Y/ z8 p
  K8 A. E# \. B1 \9 t int main(void)
# t% I6 s' s/ P4 T& ]0 j {
  char str_1[100] = "heLlo,world";
  char str_2[100] = "heLlo,world";
. v5 y* X. {" |# ]  sky_memecpy_1(str_1+1,str_1,strlen(str_1));
. n7 `! d- N7 K! e" L3 K  printf("%s\n",str_1);
  
  sky_memecpy(str_2+1,str_2,strlen(str_2));
  printf("%s\n",str_2);
  return (0);
/ P/ q; n0 n; |! u5 L  _ }

程序输出

hhhhhhhhhhhh
9 C! q' z( ^& d' FhheLlo,world
* ?2 s9 {+ f2 ~
--------------------------------
( y! b8 I9 c+ P$ x! V2 |7 l6 f$ qProcess exited after 0.02773 seconds with return value 0
) @2 }6 X/ `: u2 D* _请按任意键继续. . .
; H/ R6 z) O4 i4 i0 i; ?% U

针对上面的拷贝覆盖问题，单独写了一个测试程序

#include "stdio.h"
1 |, b1 q. ]2 R1 E4 S#include "string.h"
2 a' O* t! g' T) S$ V+ U
void *sky_memecpy(void *dst, const void *str, int n)
{
if (NULL == dst || NULL == str || n <= 0) {
  return NULL;
}
, Y" f* u3 z+ T; y char *pdst = (char *)dst;
char *pstr = (char *)str;
while (n --) {
" T2 X6 B0 |) {. S6 E  printf("dst:%c--->str:%c\n",*pdst,*pstr);
  *pdst ++ = *pstr ++;
6 N1 K- z" E  q: \, O }
return dst;
}
1 N7 q  {& h7 L
* |6 B* t+ R: e: Y+ Oint main(void)
{
9 R7 n. }  x" o" w4 `8 h, M2 Z, w char str_1[100] = "heLlo,world";
2 G7 S3 v) T7 m" Y9 a/ T* I( j8 \ sky_memecpy(str_1+1,str_1,strlen(str_1));
5 f( S( n0 T7 S printf("%s\n",str_1);
- `6 \- t% E1 O  M& P return (0);
( Z  V* u' v' X. I8 k6 |}
( e9 ^  s+ ]  j' ~5 `

程序输出

dst:e--->str:h
& G* u+ l5 _# T7 j' R: odst--->str:h
dst:l--->str:h
9 J2 G) Q- D$ ^/ p  X8 Ddst--->str:h
dst:,--->str:h
dst:w--->str:h
3 l+ K9 A3 R' |- |$ `$ [( F; Jdst--->str:h
3 `+ V  Y6 P% G. Vdst:r--->str:h
dst:l--->str:h
5 h$ ^0 m! V, ^9 Idst:d--->str:h
8 Q9 e" f" \/ U6 ?+ Qdst: --->str:h
hhhhhhhhhhhh

) D+ V( T  C1 j  R, R# P--------------------------------
Process exited after 0.02575 seconds with return value 0
% l/ Z* _9 y8 t3 s请按任意键继续. . .

初始的时候，dst指向 e 字符，str 指向h 字符，然后每次都是dst先移动，str再移动，就出现了dst被h字符所覆盖。