class string

最新推荐文章于 2024-08-01 04:45:18 发布
最新推荐文章于 2024-08-01 04:45:18 发布
阅读量1.3k 收藏
点赞数
分类专栏： c++ 习题 文章标签： string class
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mzx1317557721/article/details/75114581
版权
习题 同时被 2 个专栏收录
13 篇文章 0 订阅
订阅专栏
c++
10 篇文章 0 订阅
订阅专栏

字符串类的增删查改

class String
{
public:
    String(const char* str = "")；
    ~String()；
    String(const String& s)；

    //const String& operator=(const String& s);
    const String& operator=(const String& s);
    void Swap(String& s);
    char* GetStr();
    size_t Len();
    size_t Capacity();

    // 增删查改 
    void PushBack(char ch);
    void PushBack(const char* str);
    void PopBack();
    void Insert(size_t pos, char ch);
    void Insert(size_t pos, const char* str);
    void Erase(size_t pos, size_t count);
    int Find(char ch) const;
    int Find(const char* str) const;
    char& operator[](size_t pos);
    bool operator==(const String& s) const;
    bool operator<(const String& s) const;
    bool operator<=(const String& s) const;
    bool operator>(const String& s) const;
    bool operator>=(const String& s) const;
    bool operator!=(const String& s)const;
    //void Expand(size_t n)

private:
    char* _str;
    size_t _len;
    size_t _capacity;
};

class_string.h

#pragma once

#include <iostream>
#include <string>
#include <assert.h>
using namespace std;

class String
{
public:
    String(const char* str = "")
        :_len(strlen(str)), _capacity(_len)
    {
        _str = (char*)malloc(_len + 1);
        strcpy(_str, str);
    }
    ~String()
    {
        free(_str);
    }
    String(const String& s)
        :_len(s._len), _capacity(s._capacity)
    {
        _str = (char*)malloc(s._capacity + 1);
        strcpy(_str, s._str);
    }

    const String& operator=(const String& s);
    void Swap(String& s);
    char* GetStr();
    size_t Len();
    size_t Capacity();

    // 增删查改 
    void PushBack(char ch);
    void PushBack(const char* str);
    void PopBack();
    void Insert(size_t pos, char ch);
    void Insert(size_t pos, const char* str);
    void Erase(size_t pos, size_t count);
    int Find(char ch) const;
    int Find(const char* str) const;
    char& operator[](size_t pos);
    bool operator==(const String& s) const;
    bool operator<(const String& s) const;
    bool operator<=(const String& s) const;
    bool operator>(const String& s) const;
    bool operator>=(const String& s) const;
    bool operator!=(const String& s)const;
    //void Expand(size_t n)

private:
    char* _str;
    size_t _len;
    size_t _capacity;
};

string.cpp

#define _CRT_SECURE_NO_WARNINGS 1

#include "class_string.h"

//const String::String& operator=(const String& s)
//{
//  if (_str != s._str)
//  {
//      String ss(s);
//      swap(_str, ss._str);
//      _len = ss._len;
//  }
//  return *this;
//}
const String& String::operator=(const String& s)
{
    if (_capacity < s._len)
    {
        _len = s._len;
        _str = (char*)realloc(_str, _len + 1);
        _capacity = _len;
    }
    strcpy(_str, s._str);
    return *this;
}
void String::Swap(String& s)
{
    swap(_str, s._str);
    swap(_len, s._len);
    swap(_capacity, s._capacity);
}
char* String::GetStr()
{
    return _str;
}
size_t String::Len()
{
    return _len;
}
size_t String::Capacity()
{
    return _capacity;
}

// 增删查改 
void String::PushBack(char ch)
{
    if (_len == _capacity)
    {
        _str = (char*)realloc(_str, ++_len + 1);
        _capacity++;
    }
    _str[_len] = '\0';
    _str[_len - 1] = ch;
}
void String::PushBack(const char* str)
{
    _len += strlen(str);
    if (_len > _capacity)
    {
        _str = (char*)realloc(_str, _len + 1);
        _capacity = _len;
    }
    //strcat(_str, str);
    char* dest = _str;
    while (*dest)dest++;
    while (*dest++ = *str++);
}
void String::PopBack()
{
    _str[--_len] = '\0';
}
void String::Insert(size_t pos, char ch)
{
    assert(pos <= _len);

    if (_len == _capacity)
    {
        _str = (char*)realloc(_str, ++_len + 1);
        _capacity = _len;
    }
    //strncat(&(_str[pos+1]), &(_str[pos]));
    int dest = _len;
    while (dest > pos)
    {
        _str[dest] = _str[dest - 1];
        dest--;
    }
    _str[pos] = ch;
}
void String::Insert(size_t pos, const char* str)
{
    //assert(pos <= _len);
    if (pos > _len)
        return;

    int len = strlen(str);
    _len += len;
    if (_len > _capacity)
    {
        _str = (char*)realloc(_str, _len + 1);
        _capacity = _len;
    }

    int i = 0;
    while (_len - i > pos + len - 1)
    {
        _str[_len - i] = _str[_len - i - len];
        i++;
    }
    int j = 1;
    while (_len - i - j + 2 >= pos + 1)
    {
        _str[_len - i - j + 1] = str[len - j];
        j++;
    }
}
void String::Erase(size_t pos, size_t count)
{
    //assert(pos < _len);
    if (pos >= _len)
        return;

    if (pos + count >= _len)
    {
        _str[pos] = '\0';
        _len = pos;
    }
    else
    {
        while (pos + count <= _len)
        {
            _str[pos] = _str[pos + count];
            pos++;
        }
        _len -= count;
    }
}
int String::Find(char ch) const
{
    //return strchr(_str, ch);
    int ret = 0;
    while (_str[ret] != ch&&_str[ret] != '\0')
        ret++;
    return _str[ret] == '\0' ? -1 : ret;
}
int String::Find(const char* str) const
{
    //return strstr(_str, str);
    if (*str == '\0')
        return _len;

    int ret = 0;
    size_t len = strlen(str);
    while (ret + len <= _len)
    {
        int i = 0;
        while (_str[ret + i] == str[i] && str[i] != '\0')
            i++;
        if (str[i] == '\0')
            return ret;
        ret++;
    }
    return -1;
}
char& String::operator[](size_t pos)
{
    return _str[pos];
}
bool String::operator==(const String& s) const
{
    if (_len == s._len)
    {
        int i = 0;
        while (_str[i] == s._str[i])
        {
            if (_str[i] == '\0')
                return true;
            i++;
        }
    }
    return false;
}
bool String::operator<(const String& s) const
{
    int i = 0;
    while (_str[i] == s._str[i])
    {
        if (_str[i] == '\0')
            return false;
        i++;
    }
    return _str[i] - s._str[i] < 0 ? true : false;
}
bool String::operator<=(const String& s) const
{
    int i = 0;
    while (_str[i] == s._str[i])
    {
        if (_str[i] == '\0')
            return true;
        i++;
    }
    return _str[i] - s._str[i] < 0 ? true : false;
}
bool String::operator>(const String& s) const
{
    int i = 0;
    while (_str[i] == s._str[i])
    {
        if (_str[i] == '\0')
            return false;
        i++;
    }
    return _str[i] - s._str[i] > 0 ? true : false;
}
bool String::operator>=(const String& s) const
{
    int i = 0;
    while (_str[i] == s._str[i])
    {
        if (_str[i] == '\0')
            return true;
        i++;
    }
    return _str[i] - s._str[i] > 0 ? true : false;
}
bool String::operator!=(const String& s)const
{
    int i = 0;
    while (_str[i] == s._str[i])
    {
        if (_str[i] == '\0')
            return false;
        i++;
    }
    return true;
}
mzx1317557721
关注
专栏目录
String类
PeppaPigwww的博客
03-17 243
1.String概述 String类在java.lang包下,所以使用的时候不需要导包 String类代表字符串，Java程序中所有字符串文字(例如"abc")都被实现为此类的实例 也就是说，Java程序中所有的双引号字符串，都是String类的对象 字符串的特点 字符串不可变，它们的值在创建后不能被更改 虽然String的值是不可变的，但是它们可以被共享 字符串效果上相当于字符数组**（char[])**，但是底层原理是字节数组(byte[]) 2.String构造方法 方法名 说明
关于String.class中的方法。
weixin_42603009的博客
05-21 4348
package cnn.bytecode.demo; import java.text.SimpleDateFormat; import java.util.Date; public class StringStudy { public static void main(String[] args) { // 时间的转换 Date date = new Date(); ...
String 转换类
11-20
日期转换、字符串转换
java String 转换成对应 Class
最新发布
weixin_42433529的博客
08-01 142
给大家整理了一些有关【字符串,Java】的项目学习资料（附讲解～～）：https://edu.51cto.com/course/35079.htmlhttps://edu.51cto.com/course/35714.html如何将 Java String 转换成对应的 Class 在 Java 编程中，有时候我们需要...
C++ string Class 使用
红羊家园
03-10 4588
C++ string class The C++ Standard Template Library (STL) contains a string class that is used in several computer science classes. In order to use the string class you should include the following s
String Class
fanbird2008的专栏
11-21 859
已知类String的原型为： class String { public:      String(const char *str = NULL);// 普通构造函数      String(const String &other);    // 拷贝构造函数      ~ String(void);    // 析构函数      String & operate =(
C++ Class string
more time
05-10 258
查找子串int pos = s.find(substr);截取子串strings substr = s.substr(pos, len); 未指定len就是到结尾转数字运用stringstream流 需要#include <sstream>stringstream ss(s); ss >> n;
C++ string class
梦想博客
06-01 1071
string::compare    C++字符串支持常见的比较操作符（>,>=,），甚至支持string与C-string的比较(如 str”test”)。在使用>,>=,这些操作符的时候是根据“当前字符特性”将字符按字典顺序进行逐一得比较。字典排序靠前的字符小，比较的顺序是从前向后比较，遇到不相等的字符就按这个位置上的两个字符的比较结果确定两个字符串的大小。同时，string(“a
学会使用string class
12-11
学会使用string class 对string class众多函数的分类与总结，适合新手了解string class的具体使用 穿插大量样例代码，内容翔实
String_Builder_Class_and_Demonstration.zip_class A
09-19
a class which allocates a string chunk and then uses memory copy methods to manipulate the data within the same string s memory. The result is a string class which can perform orders of magnitude ...
spark系列case class学习
dataastron的博客
01-02 3576
scala> case class Message(sender: String, recipient: String, body: String) defined class Messagescala> val message1 = Message("guillaume@quebec.ca", "jorge@catalonia.es", "Ça va ?") message1: Message =
Cannot convert 0:0 of type class java.lang.String to class java.lang.Long
Dai_bozhong的专栏
04-11 9304
订单状态：           下单登记           支付成功           待支付           支付确认           支付失败   造成错误： javax.el.ELException: Cannot convert 0:0 of type class java.lang.String to class java.lang.Long  at org
C++之＜string class＞
gangaue的博客
06-05 717
这篇文章注意学习string类的基本用法和底层原理！！！string class是标准库中模板类的一个实例，底层是类似一个动态数组【1】字符串转整形 【2】字符串相加注意：在OJ中，有关字符串的题目基本以string类的形式出现，而且在常规工作中，为了简单、方便、快捷，基本都使用string类，很少有人去使用C库中的字符串操作函数【string文档介绍】 注意：这个类独立于所使用的编码来处理字节 如果用来处理多字节或变长字符(如UTF-8)的序列，个类的所有成员(如长度或大小)以及它的迭代器，将仍然按照字节
C++ string用法详解
chenwk891的专栏
07-13 760
C++ string 详解 任何人对本文进行引用都要标明作者是Nicolai M.Josuttis /////////////////////////////////////////////////////////////////////////////////// C++ 语言是个十分优秀的语言，但优秀并不表示完美。还是有许多人不愿意使用C或者C++，为什么？原因众多，其中之一就是
string class操作
qq_41961154的博客
05-05 668
C++ 使用 string 类处理字符串 1.string类中的函数 (1) 构造 (2) 追加 (3) 赋值 (4) 位置与清除 (5) 长度与容量 (6) 比较 (7) 子 串 (8) 搜索 (9) 运算符 2. 注意事项 操作string对象中的字符串内容时，有时会用到“index”。 很多string的函数接受两个数字...
string class （字符串类的设计，带指针的class）
Nick
01-15 637
包括内容： 深度拷贝：类中指针所指向的区域 需要拷贝 new：先分配memory，再调用构造函数 delete：先调用析构函数，再释放memory 动态分配内存 堆、栈的区别 内存分配方式的可视化（release and debug） big three：拷贝构造、拷贝赋值、析构函数 new/delete配合使用，注意加 [ ]   代码： mystring.h #ifn...
C++中class String类的定义
nonths的专栏
04-02 696
之前在网上看到一些关于String类的定义，然后在电脑上运行了一下，发现很多运行的时候都会出错，很苦恼。所以花了一点时间修改了一下，哈哈，现在可以了，调用任何一个函数都不会出错了，分享一下。   源代码如下： #include #include using namespace std; class String {  public :   //String();   String (const
c++ 学习笔记--class String(02)
NiMiKiss的博客
08-22 227
class String #ifndef __STRING__ #define __STRING__ #define _CRT_SECURE_NO_WARNINGS #include <cstring> class String { public: //构造函数，传入字符串指针 String(const char* cstr=0); String(const String&am
Class String
qq_53419616的博客
03-11 328
定义 字符串是不变的; 它们的值在创建后无法更改。 字符串缓冲区支持可变字符串。 因为String对象是不可变的，所以可以共享它们。 对String不可变理解 String str = "123"; String str1 = "12"; int a = str1.hashCode(); //此时str1与str内容相同 str1 = str1+"3"; //对比str与str1的哈希码值 if
解释public static class StringExtension
06-10
- class：表示该声明是一个类的声明。 - StringExtension：表示该类的名称。 因此，这行代码声明了一个名为StringExtension的公开静态类，该类中包含了一些扩展方法（extension method）用于对字符串进行操作。可以...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值