1.不使用库函数将整数转换为字符串
C语言提供了将几个标准库函数，可以将任意类型的（整形、浮点型、长整形）的数字转换为字符串
itoa（）:将整形值转换为字符串
ltoa（）;将长整形转换为字符串
ultoa（）；将无符号长整形转换为字符串
gcvt（）；将浮点数转换为字符串，取四舍五入
ecvt（）；将双精度浮点数转换为字符串，转换结果中不包含十进制小数点
fcvt（）；将指定位数转换精度
还可以使用sprintf系类函数把数字转换为字符串，这种方式比itoa系列函数速度慢
#include<stdio.h>
#include<iostream>
using namespace std;
void int2str(int n, char*str)
{
char buf[10] = {0}; //临时数组
int i = 0; //临时数组buf的下标
int j = 0; //str的下标
int len=0;
int temp = n < 0 ? -n : n; //取数字n的绝对值
if (n < 0) //首先对负数做处理
{
str[j] = '-';
j++;
}
//将数字倒序放在临时数组
while (temp)
{
buf[i] = temp%10 + '0';
i++;
temp /= 10;
}
//转换
len = i - 1;
while (len>=0)
{
str[j] = buf[len];
j++;
len--;
}
str[j] = '\0';
}
int main()
{
int num;
char p[10];
cout << "please input the number:" << endl;
cin >> num;
int2str(num, p);
cout << "ouput: " << p << endl;
return 0;
}-1234
ouput: -1234
2.不使用库函数将字符串转换为数字
与数字转换为字符串类似，C/C++提供了几个标准的库函数，可以将字符串转换为任意类型（整型，长整型，浮点型）的数字。下面列举其函数
atof（）；将字符串转换为双精度浮点型值
atoi（）；将字符串转换为整型值
atol（）；将字符串转换为长整型
strtod（）；将字符串转换为双精度浮点型值，并报告不能被转换的所有剩下数字
strtol（）；将字符串转换为长整型值，并报告不能被转换的所有剩下的数字
strtoul（）；将字符串转换为无符号长整型，并报告不能被转换的所有剩下的数字
//2.不使用库函数将数字符串转换为数字
#include<iostream>
using namespace std;
int str2int(const char * str)
{
int temp=0;
const char *ptr = str; //ptr保存str字符串开头
if (*str == '-' || *str == '+') //如果第一个字符是正负号，则移到下一个字符
{
str++;
}
while (*str != 0)
{
if ((*str < '0') || *str > '9') //如果当前字符不是数字，则退出循环
{
break;
}
temp = temp * 10 + (*str - '0'); //如果当前字符是数字，则计算数值，然后移到下一个字符
str++;
}
if(*ptr=='-') //如果字符串以‘-’开头，则转换成其相反数
{
temp = -temp;
}
return temp;
}
int main()
{
int n = 0;
char p[10] = "";
cout << "input: " << endl;
//cin >> p[10];
cin.getline(p, 20);
n = str2int(p);
cout << "output:" << n << endl;
return 0;
}input:
-1234
output:-1234
3.编程实现strcpy函数
//3.编程实现strcpy函数
#include<stdio.h>
char * strcpy(char * strDest, const char * strSrc)
{
if ((strDest == NULL) || (strSrc == NULL))
{
return NULL;
}
char *strDestCopy = strDest; //保存目标字符串的首地址
int i = 0;
//for (i = 0; strSrc[i] != '\0'; strDest[i] = strSrc[i], i++)
while (strSrc[i]!='\0')
{
strDest[i] = strSrc[i]; //把strSrc字符串的内容复制到strDest中
i++;
}
strDest[i] = '\0'; //加入结束符
return strDestCopy; //返回首地址
}
int main()
{
char strSrc[] = "hello world";
char strDest[20];
strcpy(strDest, strSrc);
printf("strDest:%s\n", strDest);
return 0;
}strDest:hello world
4.编程实现计算字符串的长度
//4.编程实现计算字符串的长度
#include<stdio.h>
int strlen1(const char* src)
{
if (src == NULL) //判断src是否有效
{
return 0;
}
int len = 0;
while (*src!='\0')
{
*src++;
len++;
}
return len;
}
int strlen2(const char* src)
{
if (src == NULL) //判断src是否有效
{
return 0;
}
const char *temp = src; //保存src的首地址
while (*src!='\0')
{
src++;
}
return (src - temp); //返回指针差
}
int main()
{
char p[] = "Hello World!";
printf("Strlen1 len: %d\n", strlen1(p));
printf("Strlen2 len: %d\n", strlen2(p));
return 0;
}
//第二种方法效率更好Strlen1 len: 12
Strlen2 len: 12
5.编程实现字符串中子串的查找
编写一个函数，实现strstr，即从一个字符串中，查找另一个字符串的位置，如果输入strstr("12345","34")返回值为2，即在2号位置找到字符串34.
#include<stdio.h>
int strstr(const char* src, const char* sub)
{
const char *bp = src; //定义指针bp指向src首地址
const char *sp = sub;
int flag = 0;
const char *temp = src; //定义一个临时指针temp，暂时先指向src首地址
if (src == NULL || sub == NULL) //判断src和sub是否有效
{
return 0;
}
while (*src) //遍历src
{
sub = sp;
while (*src == *sub) //如果src与sub字符相等进入，如果不等，src++
{
src++; //然后src和sbu都加1，比较下一个字符是否相等
sub++;
flag = 1;
if (*sub == '\0') //如果sub结束了，那就是找到了子串
{
return (temp - bp); //输出子串的位置，bp是首地址，temp存储的是第一个相等字符的前一个
break; //字符的位置，然后与首地址相减再加1，就得到最终结果
}
}
if (flag == 1) //flag的作用是如果在上一个while循环中src执行了+1，这里就不需要再执行一次了
{ //所有先对src--，然后在src++
src--;
flag = 0;
}
src++; //src加1，比较下一个字符
temp = src;
if (*src == '\0') //如果src下一个字符是空，那就结束，
{
return 0;
}
}
}
int main()
{
char p[] = "123345";
char q[] = "34";
printf("the position of sub is : %d\n", strstr(p, q));
return 0;
}6.编程判断字符串是否是回文，例如“level”是回文
//6.编程判断字符串是否是回文
//例如“level”是回文
#include<iostream>
using namespace std;
int IsRevStr(char * str)
{
int i, len;
int found = 1; //1表示是回文，0表示不是回文
if (str == NULL)
{
return -1;
}
len = strlen(str);
for (i = 0; i < len / 2; i++)
{
if (str[i] != str[len - i - 1]) //不是回文
{
found = 0;
break;
}
}
return found;
}
int main()
{
char str1[] = "1234321";
char str2[] = "1234221";
int test1 = IsRevStr(str1);
int test2 = IsRevStr(str2);
cout << "str1 is " << (test1 == 1 ? "" : "not ") << "reverse string." << endl;
cout << "str2 is " << (test2 == 1 ? "" : "not ") << "reverse string." << endl;
return 0;
}str1 is reverse string.
str2 is not reverse string.
7.编程实现stcmp库函数
对于两个字符串str1，str2，若相等，则返回0，若str1大于str2，则返回1，若str1小于str2，则返回-1
//7.编程实现stcmp库函数
//对于两个字符串str1，str2，若相等，则返回0，若str1大于str2，则返回1，若str1小于str2，则返回-1
#include<iostream>
using namespace std;
int mystrcmp(const char*src, const char* dst)
{
int ret = 0;
while (!(ret=*(unsigned char *)src-*(unsigned char *)dst) && *dst)
{
src++; //循环比较两个字符串是否相等，如果不等或者dst字符串到了末尾，退出循环，
dst++; //与后面的*dst和*src有一个在就可以，如果src到了结尾，而dst没到结尾，则!ret=0,同样会结束循环
}
if (ret < 0)
ret = -1;
else if (ret > 0)
ret = 1;
return ret;
}
int main()
{
char str[10] = "1234567";
char str1[10] = "1234567";
char str2[10] = "12345678";
char str3[10] = "1234566";
int test1 = mystrcmp(str, str1);
int test2 = mystrcmp(str, str2);
int test3 = mystrcmp(str, str3);
cout << "test1 = " << test1 << endl;
cout << "test2 = " << test2 << endl;
cout << "test3 = " << test3 << endl;
return 0;
}test1 = 0
test2 = -1
test3 = 1
8.编写字符串反转函数strrev
如：输入“abcd”,输出应为“dcba”
//8.编写字符串反转函数strrev
#include<iostream>
using namespace std;
char* strrev1(char* str) //遍历字符串
{ //第一个与最后一个交换，依次循环
int len = strlen(str);
char *tmp = new char[len + 1];
strcpy_s(tmp,len+1,str);
for (int i = 0; i < len / 2; i++)
{
char c = tmp[i];
tmp[i] = tmp[len - i-1];
tmp[len - i - 1] = c;
}
return tmp;
}
int main()
{
char * str = "123456";
cout << str << endl;
char* str1 = strrev1(str);
cout << "strrev1(str) = " << str1 << endl;
return 0;
}123456
strrev1(str) = 654321
9.编程实现任意长度的两个正整数相加
//9.编程实现任意长度的两个正整数相加
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<math.h>
char * addBigInt(char * num1, char *num2)
{
int c = 0;// 进位，开始最低进位为0
int i = strlen(num1)-1; //指向第一个加数的最低位
int j = strlen(num2)-1; //指向第二个加数的最低位
//得到两个数中较大数的位数并加1，作为结果的位数
int maxLength = strlen(num1) >= strlen(num2) ? strlen(num1) + 1 : strlen(num2) + 1;
char *rst = (char*)malloc(maxLength + 1); //保存结果
int k;
if (rst == NULL)
{
printf("malloc error\n");
exit(1);
}
rst[maxLength] = '\0'; //字符串最后一位为'\0';
k = strlen(rst) - 1; //指向结果数组的最低位
while ((i>=0)&&(j>=0))
{
rst[k] = ((num1[i] - '0') + (num2[j] - '0') + c) % 10 + '0';
c = ((num1[i] - '0') + (num2[j] - '0') + c) / 10;
i--;
j--;
k--;
}
while (i>=0)
{
rst[k] = ((num1[i] - '0')+ c) % 10 + '0';
c = ((num1[i] - '0')+ c) / 10;
i--;
k--;
}
while (j>=0)
{
rst[k] = ((num2[j] - '0') + c) % 10 + '0';
c = ((num2[j] - '0') + c) / 10;
j--;
k--;
}
rst[0] = c +'0';
if (rst[0] !='0')
{
return rst;
}
else
{
return rst + 1; //如果最高位等于零，那么就从结果str的第二个元素开始输出
}
}
int main()
{
char num1[] = "123";
char num2[] = "996";
char *result = NULL;
result = addBigInt(num1, num2);
printf("%s + %s = %s\n", num1, num2, result);
return 0;
}123 + 996 = 1119
10.编程实现字符串的循环右移
编写函数能把一个char组成的字符串循环右移n个，例如原来是“abcdefghi”，如果n=2，移位后应该是“hiabcdefg”
//10.编程实现字符串的循环右移
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
void loopMove(char* str, int n)
{
int i = 0;
char *temp = NULL;
int strLen = strlen(str);
char *head = str;
n = n%strLen;
temp = (char*)malloc(n);
for (i = 0; i < n; i++)
{
temp[i] = head[strLen - n + i];
}
for (i = strLen - 1; i >= n; i--)
{
head[i] = head[i - n];
}
for (i = 0; i < n; i++)
{
head[i] = temp[i];
}
free(temp);
}
int main()
{
char string[] = "abcdefghi";
int steps = 0;
printf("string: %s\n", string);
printf("input steps: ");
scanf_s("%d", &steps);
loopMove(string,steps);
printf("after loopMove %d: %s\n", steps, string);
return 0;
}input steps: 2
after loopMove 2: hiabcdefg
11.删除制定长度的字符
例如：假设一个字符串“abcdefg”，如果要从第二个开始（索引为1），删除两个字符，则删除后的字符串是“adefg”
//11.删除制定长度的字符
#include<stdio.h>
#include<string.h>
#include<iostream>
using namespace std;
char *deleteChars(char* str, int pos, int len)
{
char *p = str + pos - 1;//指向pos位置字符
int tt = strlen(str); //计算字符长度
if ((pos < 1) || (p - str) > tt) //检查pos是否大于1，或者pos超出字符串的长度
{
return str;
}
if ((p + len - str) > tt) //len大于pos后剩余的字符个数
{
while (*p) //那就把pos后面的全部删掉，直到结束
{
*p = '\0';
p++;
}
}
while (*p && *(p+len))
{
*p = *(p + len);
p++;
}
*p = '\0';
return str;
}
int main()
{
char string[] = "abcdefg";
int pos = 0;
int len = 0;
int steps = 0;
printf("string: %s\n", string);
printf("input pos: ");
cin >> pos;
cout << "input len: ";
cin >> len;
deleteChars(string, pos, len);
printf("after delete %d chars behind pos %d: %s\n", len, pos, string);
return 0;
}string: abcdefg
input pos: 2
input len: 2
after delete 2 chars behind pos 2: adefg
12.编程实现删除字符串中所有指定的字符
假设字符串为“cabcdefcgchci”，把该字符串中所有的字符'c'删除后，结果为“abdefghi”
//12.编程实现删除字符串中所有制定的字符
#include<stdio.h>
#include<iostream>
using namespace std;
char * deleteChar(char* str, char c)
{
char* head = str;
char* p = str;
if (str == NULL) //检查str的有效性
{
return NULL;
}
while (*p)
{
if (*p != c)
{
*str = *p; //如果不等于c的值，则记录在str中
str++;
}
p++;
}
*str = '\0'; //结束符
return head;
}
int main()
{
char string[] = "cabcdefcgchci";
char c = 0;
cout << "input char: ";
cin >> c;
cout << "before delete: " << string << endl;
deleteChar(string, c); //删除所有的c
cout << "after delete: " << string << endl;
return 0;
}input char: c
before delete: cabcdefcgchci
after delete: abdefghi
13.编程实现库函数strcat，实现字符串的拼接
//13.编程实现库函数strcat，拼接函数
#include<stdio.h>
#include<stdlib.h>
#include<iostream>
using namespace std;
char *mystrcat(char *dest, const char* src)
{
char *ret = dest;//保存目的字符串的首地址，以便返回
while (*dest)
{
dest++;
}
while (*src)
{
*dest = *src;
src++;
dest++;
}
*dest = '\0'; //结束符
return ret;
}
int main()
{
char *dest = NULL;
char *str1 = "Hello ";
char *str2 = "World!";
dest = (char*)malloc(256);
*dest = '\0'; //dest里面是空
mystrcat(mystrcat(dest, str1), str2);
cout << "dest: " << dest << endl;
free(dest);
dest = NULL;
return 0;
}dest: Hello World!
原创文章 100
获赞 339
访问量 56万+