投稿
  1. 高性能架构探索首页
  2. C/C++

C/C++ 字符串拷贝处理

admin • • C/C++ • 阅读 170

C语言的字符串操作

strtok 实现字符串切割: 将字符串根据分隔符进行切割分片.

#include <stdio.h>

int main(int argc, char* argv[])
{
    char str[] = "hello,lyshark,welcome";
    char *ptr;

    ptr = strtok(str, ",");
    while (ptr != NULL)
    {
        printf("切割元素: %s\n", ptr);
        ptr = strtok(NULL, ",");
    }
    system("pause");
    return 0;
}

strlen 获取字符串长度:

#include <stdio.h>

int main(int argc, char* argv[])
{
    char Array[] = "\0hello\nlyshark";
    char Str[] = { 'h', 'e', 'l', 'l', 'o' };

    int array_len = strlen(Array);
    printf("字符串的有效长度：%d\n", array_len);
    int str_len = strlen(Str);
    printf("字符串数组有效长度: %d\n", str_len);

    int index = 0;
    while (Str[index] != '\0')
    {
        index++;
        printf("Str数组元素: %c --> 计数: %d \n", Str[index], index);
    }

    system("pause");
    return 0;
}

strcpy 字符串拷贝:

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

int main(int argc, char* argv[])
{
    char Array[] = "hello lyshark";
    char tmp[100];

    // 学习strcpy函数的使用方式
    if (strcpy(tmp, Array) == NULL)
        printf("从Array拷贝到tmp失败\n");
    else
        printf("拷贝后打印: %s\n", tmp);

    // 清空tmp数组的两种方式
    for (unsigned int x = 0; x < strlen(tmp); x++)
        tmp[x] = ' ';

    memset(tmp, 0, sizeof(tmp));

    // 学习strncpy函数的使用方式
    if (strncpy(tmp, Array, 3) == NULL)
        printf("从Array拷贝3个字符到tmp失败\n");
    else
        printf("拷贝后打印: %s\n", tmp);

    system("pause");
    return 0;
}

strcat字符串连接: 将由src指向的空终止字节串的副本追加到由dest指向的以空字节终止的字节串的末尾

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

int main(int argc, char* argv[])
{
    char str1[50] = "hello ";
    char str2[50] = "lyshark!";

    char * str = strcat(str1, str2);
    printf("字符串连接: %s \n", str);

    str = strcat(str1, " world");
    printf("字符串连接: %s \n", str);

    str = strncat(str1, str2, 3);
    printf("字符串连接: %s \n", str);

    system("pause");
    return 0;
}

strcmp 字符串对比:

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

int Str_Cmp(const char * lhs, const char * rhs)
{
    int ret = strcmp(lhs, rhs);
    if (ret == 0)
        return 1;
    else
        return 0;
}

int main(int argc, char* argv[])
{
    char *str1 = "hello lyshark";
    char *str2 = "hello lyshark";

    int ret = Str_Cmp(str1, str2);
    printf("字符串是否相等: %d \n", ret);

    if (!strncmp(str1, str2, 3))
        printf("两个字符串,前三位相等");

    system("pause");
    return 0;
}

strshr 字符串截取:

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

int main(int argc, char* argv[])
{
    const char str[] = "hello ! lyshark";
    char *ret;

    ret = strchr(str, '!');
    printf("%s \n", ret);

    system("pause");
    return 0;
}

字符串逆序排列:

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

void Swap_Str(char *Array)
{
    int len = strlen(Array);
    char *p1 = Array;
    char *p2 = &Array[len - 1];
    while (p1 < p2)
    {
        char tmp = *p1;
        *p1 = *p2;
        *p2 = tmp;
        p1++, p2--;
    }
}

int main(int argc, char* argv[])
{
    char str[20] = "hello lyshark";
    Swap_Str(str);

    for (int x = 0; x < strlen(str); x++)
        printf("%c", str[x]);

    system("pause");
    return 0;
}

实现字符串拷贝:

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

// 使用数组实现字符串拷贝
void CopyString(char *dest,const char *source)
{
    int len = strlen(source);
    for (int x = 0; x < len; x++)
    {
        dest[x] = source[x];
    }
    dest[len] = '\0';
}

// 使用指针的方式实现拷贝
void CopyStringPtr(char *dest, const char *source)
{
    while (*source != '\0')
    {
        *dest = *source;
        ++dest, ++source;
    }
    *dest = '\0';
}
// 简易版字符串拷贝
void CopyStringPtrBase(char *dest, const char *source)
{
    while (*dest++ = *source++);
}

int main(int argc, char* argv[])
{
    char * str = "hello lyshark";
    char buf[1024] = { 0 };
    CopyStringPtrBase(buf, str);
    printf("%s \n", buf);

    system("pause");
    return 0;
}

格式化字符串:

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

int main(int argc, char* argv[])
{
    // 格式化填充输出
    char buf[30] = { 0 };
    sprintf(buf, "hello %s %s", "lyshark","you are good");
    printf("格式化后: %s \n", buf);

    // 拼接字符串
    char *s1 = "hello";
    char *s2 = "lyshark";
    memset(buf, 0, 30);
    sprintf(buf, "%s --> %s", s1, s2);
    printf("格式化后: %s \n", buf);

    // 数字装换位字符串
    int number = 100;
    memset(buf, 0, 30);
    sprintf(buf, "%d", number);
    printf("格式化后: %s \n", buf);

    system("pause");
    return 0;
}

动态存储字符串:

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

int main(int argc, char* argv[])
{
    // 分配空间
    char **p = malloc(sizeof(char *)* 5);
    for (int x = 0; x < 5;++x)
    {
        p[x] = malloc(64); 
        memset(p[x], 0, 64);
        sprintf(p[x], "Name %d", x + 1);
    }

    // 打印字符串
    for (int x = 0; x < 5; x++)
        printf("%s \n", p[x]);

    // 释放空间
    for (int x = 0; x < 5; x++)
    {
        if (p[x] != NULL)
            free(p[x]);
    }

    system("pause");
    return 0;
}

字符串拼接:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

char * StringSplicing(char *String1, char  *String2)
{
    char Buffer[1024];

    int index = 0;
    int len = strlen(String1);
    while (String1[index] != '\0')
    {
        Buffer[index] = String1[index];
        index++;
    }
    while (String2[index - len] != '\0')
    {
        Buffer[index] = String2[index - len];
        index++;
    }
    Buffer[index] = '\0';

    char *ret = (char*)calloc(1024, sizeof(char*));
    if (ret)
        strcpy(ret, Buffer);
    return ret;
}

int main(int argc, char* argv[])
{
    char *str1 = "hello ";
    char *str2 = "lyshark ! \n";

    char * new_str = StringSplicing(str1, str2);
    printf("拼接好的字符串是: %s", new_str);

    system("pause");
    return 0;
}

实现strchr:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

char * MyStrchr(const char *String, char ch)
{
    char *ptr = String;
    while (*ptr != '\0')
    {
        if (*ptr == ch)
            return ptr;
        ptr++;
    }
    return NULL;
}

int main(int argc, char* argv[])
{
    char Str[] = "hello lyshark";
    char ch = 's';

    char *ptr = MyStrchr(Str, ch);
    printf("输出结果: %s \n", ptr);

    system("pause");
    return 0;
}

自己实现寻找字符串子串:

#include <stdio.h>
#include <stdlib.h>

// 查找子串第一次出现的位置
char *MyStrStr(const char* str, const char* substr)
{
    const char *mystr = str;
    const char *mysub = substr;

    while (*mystr != '\0')
    {
        if (*mystr != *mysub)
        {
            ++mystr;
            continue;
        }

        char *tmp_mystr = mystr;
        char *tmp_mysub = mysub;

        while (tmp_mysub != '\0')
        {
            if (*tmp_mystr != *tmp_mysub)
            {
                ++mystr;
                break;
            }
             ++tmp_mysub;
        }


        if (*tmp_mysub == '\0')
        {
            return mystr;
        }
    }
    return NULL;
}

int main(int argc, char* argv[])
{

    char *str = "abcdefg";
    char *sub = "fg";

    char * aaa = MyStrStr(str, sub);

    printf("%s", aaa);

    system("pause");
    return 0;
}

删除字符串中连续字符

#include <stdio.h>
char del(char s[],int pos,int len)   //自定义删除函数，这里采用覆盖方法
 {
   int i;
   for (i=pos+len-1; s[i]!='\0'; i++,pos++)
     s[pos-1]=s[i];   //用删除部分后的字符依次从删除部分开始覆盖
   s[pos-1]='\0';
   return s;
 }
int main(int argc, char *argv[])
{
  char str[50];
  int position,length;
  printf ("please input string:\n");
  gets(str);   //使用gets函数获得字符串
  printf ("please input delete position:");
  scanf("%d",&position);
  printf ("please input delete length:");
  scanf("%d",&length);
  del(str,position,length);
  printf ("the final string:%s\n",str);
  return 0;
}

C++的字符串操作

在C语言中想要输出数据需要使用Printf来实现,但C++中引入了另一种输出方式,C++中形象的将此过程称为流,数据的输入输出是指由若干个字节组成的字节序列,这些序列从一个对象中传递到另一个对象,我们将此过程形象的表示为数据的流,数据流可以包括ASCII字符,二进制数据,图形图像数据,音频数据等,流都将可以操作.

字符串类的初始化:

#include <iostream>
#include <string>
using namespace std;

int main(int argc, char* argv[])
{
    string str("hello lyshark"); // 定义一个字符串

    string str_1(str);           // 构造函数,将 str中的内容全部复制到str_1
    cout << str_1 << endl;
    string str_2(str, 2, 5);     // 构造函数,从字符串str的第2个元素开始,复制5个元素,赋值给str_2
    cout << str_2 << endl;
    string str_3(str.begin(), str.end()); // 复制字符串 str 的所有元素，并赋值给 str_3
    cout << str_3 << endl;

    char ch[] = "lyshark";
    string str_4(ch, 3);    // 将字符串ch的前5个元素赋值给str_4
    cout << str_4 << endl;

    string str_5(5, 'x');   // 将 5 个 'X' 组成的字符串 "XXXXX" 赋值给 str_5
    cout << str_5 << endl;

    system("pause");
    return 0;
}

标准输出流: 首先我们演示标准的输入输出,其需要引入头文件<iostream>

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>

using namespace std;

int main(int argc, char* argv[])
{
    char str[] = "lyshark";
    int number = 0;

    cout << "hello: " << str << endl;
    cin >> number;
    if (number == 0)
    {
        cerr << "Error msg" << endl;  // 标准的错误流
        clog << "Error log" << endl;  // 标准的日志流
    }

    int x, y;
    cin >> x >> y;                      // 一次可以接受两个参数
    freopen("./test.log", "w", stdout); // 将标准输出重定向到文件

    system("pause");
    return 0;
}

格式化输出: 在程序中一般用cout和插入运算符“<<”实现输出，cout流在内存中有相应的缓冲区。

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <iomanip>

using namespace std;

int main(int argc, char* argv[])
{
    cout << hex << 100 << endl;             // 十六进制输出
    cout << dec << 100 << endl;             // 十进制输出
    cout << oct << 100 << endl;             // 八进制输出
    cout << fixed << 10.053 << endl;        // 单浮点数输出
    cout << scientific << 10.053 << endl;   // 科学计数法

    cout << setw(10) << "hello" << setw(10) << "lyshark" << endl;  // 默认两个单词之间空格

    cout << setfill('-') << setw(10) << "hello" << endl; // 指定域宽,输出字符串,空白处以'-'填充

    for (int x = 0; x < 3; x++)
    {
        cout << setw(10) << left << "hello" ; // 自动(left/right)对齐,不足补空格
    }

    cout << endl;
    system("pause");
    return 0;
}

单个字符输出: 流对象中,提供了专用于输出单个字符的成员函数put

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <iomanip>

using namespace std;

int main(int argc, char* argv[])
{
    char *str = "lyshark";

    for (int x = 6; x >= 0; x--)
        cout.put(*(str + x));  // 每次输出一个字符
    cout.put('\n');

    system("pause");
    return 0;
}

标准输入流: 通过测试cin的真值,判断流对象是否处于正常状态.

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <iomanip>

using namespace std;

int main(int argc, char* argv[])
{
    float grade;

    while (cin >> grade)
    {
        if (grade >= 85)
            cout << grade << " good" << endl;
    }
    system("pause");
    return 0;
}

读取字符串: getline函数的作用是从输入流中读取一行字符

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <iomanip>

using namespace std;

int main(int argc, char* argv[])
{
    char str[20];
    int x, y, z;

    cin >> x >> y >> z;
    cout << x << y << z;

    cin.getline(str, 20);        // 读入字符遇到\n结束读取
    cout << str << endl;

    cin.getline(str, 20, 'z');  // 读入字符遇到z字符才结束
    cout << str << endl;

    system("pause");
    return 0;
}

原文链接: https://www.cnblogs.com/LyShark/p/12869454.html

欢迎关注

微信关注下方公众号，第一时间获取干货硬货；公众号内回复【pdf】免费获取数百本计算机经典书籍;

也有高质量的技术群，里面有嵌入式、搜广推等BAT大佬

    C/C++ 字符串拷贝处理

原创文章受到原创版权保护。转载请注明出处：https://www.ccppcoding.com/archives/347754

非原创文章文中已经注明原地址，如有侵权，联系删除

关注公众号【高性能架构探索】，第一时间获取最新文章

转载文章受原作者版权保护。转载请注明原作者出处！

赞 (0)
adminadmin
0 0
上一篇 2023年3月2日 上午4:36
下一篇 2023年3月2日 上午4:41

相关推荐