C++ String类的模拟实现

于 2024-06-14 21:40:52 发布
阅读量368 收藏 9
点赞数 4
文章标签： c++ 开发语言 容器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_73874574/article/details/139665491
版权

string类(了解)

1. 字符串是表示字符序列的类
2. 标准的字符串类提供了对此类对象的支持，其接口类似于标准字符容器的接口，但添加了专门用于操作单字节字符字符串的设计特性。
3. string类是使用char(即作为它的字符类型，使用它的默认char_traits和分配器类型(关于模板的更多信息，请参阅basic_string)。
4. string类是basic_string模板类的一个实例，它使用char来实例化basic_string模板类，并用char_traits和allocator作为basic_string的默认参数(根于更多的模板信息请参考basic_string)。
5. 注意，这个类独立于所使用的编码来处理字节:如果用来处理多字节或变长字符(如UTF-8)的序列，这个类的所有成员(如长度或大小)以及它的迭代器，将仍然按照字节(而不是实际编码的字符)来操作。
总结：

1. string是表示字符串的字符串类
2. 该类的接口与常规容器的接口基本相同，再添加了一些专门用来操作string的常规操作。
3. string在底层实际是：basic_string模板类的别名，typedef basic_string<char, char_traits, allocator> string;
4. 不能操作多字节或者变长字符的序列。

string的具体接口如下：
 

#pragma once
#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<assert.h>
using namespace std;
 
namespace mystring
{
     class string
    {
        friend ostream& operator<<(ostream& _cout, const string& s);

        friend istream& operator>>(istream& _cin, bit::string& s);

    public:
        // 迭代器
        typedef char* iterator;
        typedef const char* const_iterator;

        const_iterator begin() const;
        const_iterator end() const;

        iterator begin();
        iterator end();
        
        // 返回c风格的字符串
        const char* c_str()const；
        
        // string()
        // 构造，拷贝构造及析构函数
        string(const char* str = "");//string(const char* str = "\0")
        string(const string& s);
        ~string();

        string& operator=(string& s);
        string& operator=(const string& s);

        // 返回pos位置的字符，const string类对象调用
        char& operator[](size_t index);
        const char& operator[](size_t index)const;

        void swap(string& s);

        // 从字符串pos位置开始往前找字符，返回该字符在字符串中的位置
        size_t find(char c, size_t pos = 0) const;
        size_t find(const char* sub, size_t pos = 0) const;

        // 返回字符串有效长度
        size_t size()const;
        // 返回空间大小
        size_t capacity()const;
        // 判空
        bool empty()const;
        // 将有效字符的个数该成n个，多出的空间用字符‘\0’填充
        void resize(size_t n, char c = '\0');
        // 为字符串预留空间
        void reserve(size_t n);
        
       
        void erase(size_t pos, size_t len = npos);
        void insert(size_t pos, char c);
        void insert(size_t pos, const char* str);

        // 在字符串后追加一个字符串
        void append(const char* str);

        // 在字符串后尾插字符
        void push_back(char c);

        // 在字符串后追加字符串str
        string& operator+=(char c);
        string& operator+=(const char* str);

        // 这个函数的功能是从pos位置开始截取长度为len的子串，如果len大于pos后面的数据个数就直接返回pos位置及其之后的数据。否则先给sub预留len个空间，然后通过遍历将从pos位置开始长度为len的字符尾插到sub中最后直接返回sub即可    
        string substr(size_t pos = 0, size_t len = npos);

        void clear();

    private:
        char* _str = nullptr;
        size_t _size = 0;
        size_t _capacity = 0;
    public:
        static const int npos;
    };
    const int string::npos = -1;

    void swap(string& x, string& y);
    bool operator<(const string& s1, const string& s2);
    bool operator<=(const string& s1, const string& s2);

    bool operator>(const string& s1, const string& s2);
    bool operator>=(const string& s1, const string& s2);

    bool operator==(const string& s1, const string& s2);
    bool operator!=(const string& s1, const string& s2);

    // 流插入和流提取
    ostream& operator<<(ostream& out, const string& s);
    istream& operator>>(istream& in, string& s);
    
}

迭代器：

        // 放在类外
        onst int string::npos = -1;       

         const_iterator begin() const
        {
            return _str;
        }

        const_iterator end() const
        {
            return _str + _size;
        }

        iterator begin()
        {
            return _str;
        }

        iterator end()
        {
            return _str + _size;
        }

c_str:

        const char* c_str()const
        {
            return _str;
        }

构造函数：

 string(const char* str = "")
            :_size(strlen(str))
        {
            _capacity = _size;
            _str = new char[_capacity + 1];
            strcpy(_str, str);
        }

拷贝构造函数：

        // 传统写法
        string(const string& s)
		{
			_str = new char[s._capacity + 1];
			strcpy(_str, s._str);
			_size = s._size;
			_capacity = s._capacity;
		}

		// 现代写法
		string(const string& s)
		{
			string tmp(s._str);
			swap(tmp);
		}

析构函数：

         ~string()
        {
            delete[] _str;
            _str = nullptr;
            _size = _capacity = 0;
        }

赋值重载：

        // 传统写法
        string& operator=(const string& s)
		{
			char* tmp = new char[s._capacity + 1];
			strcpy(tmp, s._str);

			delete[] _str;
			_str = tmp;
			_size = s._size;
			_capacity = s._capacity;

			return *this;
		}

        // 现代写法
         string& operator=(string& s)
        {
            swap(s);
            return *this;
        }

operator [ ]:

        char& operator[](size_t index)
        {
            assert(index < _size);
            return _str[index];
        }

        const char& operator[](size_t index)const
        {
            assert(index < _size);
            return _str[index];
        }

void swap(string& s):

         void swap(string& s)
        {

            std::swap(_str, s._str);
            std::swap(_size, s._size);
            std::swap(_capacity, s._capacity);
        }

find 查找接口：

         size_t find(char c, size_t pos = 0) const
        {
            assert(pos < _size);
            for (int i = pos; i < _size; i++)
            {
                if (_str[i] == c)
                    return i;
            }
            return npos;
        }

        size_t find(const char* sub, size_t pos = 0) const
        {
            assert(pos < _size);
            const char* p = strstr(_str + pos, sub);
            if (p)
                return p - _str;
            else
                return npos;
        }

容量操作接口：

size:

        size_t size()const
        {
            return _size;
        }

capacity:

         size_t capacity()const
        {
            return _capacity;
        }

empty:

         bool empty()const
        {
            return _str;
        }

resize:

        void resize(size_t n, char c = '\0')
        {
            if (n <= _size)
            {
                _str[n] = '\0';
                _size = n;
            }
            else
            {
                reserve(n);
                for (int i = _size; i < n; i++)
                {
                    _str[i] = c;
                }
                _str[n] = '\0';
                _size = n;

            }
        }

reserve:

         void reserve(size_t n)
        {
            if (n > _capacity)
            {
                char* tmp = new char[n + 1];
                strcpy(tmp, _str);
                delete[] _str;
                _str = tmp;
                _capacity = n;
            }

修改及访问操作接口:

erase:

        void erase(size_t pos, size_t len = npos)
        {
            assert(pos < _size);
            if (pos == npos || len >= _size - pos)
            {
                _str[pos] = '\0';
                _size = pos;
            }
            else
            {
                strcpy(_str + pos, _str + pos + len);
                _size -= len;
            }
        }

insert:

        void insert(size_t pos, char c)
        {
            assert(pos <= _size);
            if (_size == _capacity)
                reserve(_capacity == 0 ? 4 : 2 * _capacity);

            size_t end = _size + 1;
            while (end > pos)
            {
                _str[end] = _str[end - 1];
                end--;
            }
            _str[pos] = c;
            ++_size;

        }

        void insert(size_t pos, const char* str)
        {
            assert(pos <= _size);
            size_t len = strlen(str);
            if (_size + len > _capacity)
            {
                reserve(_size + len);
            }
            size_t end = _size + len;
            while (end > pos + len - 1)//end - len +1 > pos
            {
                _str[end] = _str[end - len];
                end--;
            }
            strncpy(_str + pos, str, len);
            _size += len;
        }

append:

        void append(const char* str)
        {
            insert(_size, str);
        }

push_back:

        void push_back(char c)
        {
            insert(_size, c);
        }

operator+=:

        string& operator+=(char c)
        {
            push_back(c);
            return *this;
        }


        string& operator+=(const char* str)
        {
            append(str);
            return *this;
        }

substr:

        string substr(size_t pos = 0, size_t len = npos)
		{
			string sub;
			//if (len == npos || len >= _size-pos)
			if (len >= _size - pos)
			{
				for (size_t i = pos; i < _size; i++)
				{
					sub += _str[i];
				}
			}
			else
			{
				for (size_t i = pos; i < pos + len; i++)
				{
					sub += _str[i];
				}
			}

			return sub;
		}

clear:

        void clear()
        {
            _size = 0;
            _str[_size] = '\0';
        }

void swap(string& x, string& y):

     void swap(string& x, string& y)
    {
        x.swap(y);
    }

运算符重载：

    bool operator<(const string& s1, const string& s2)
    {
        int ret = strcmp(s1.c_str(), s2.c_str());
        return ret < 0;
    }

    bool operator<=(const string& s1, const string& s2)
    {
        return s1 < s2 || s1 == s2;
    }

    bool operator>(const string& s1, const string& s2)
    {
        return !(s1 <= s2);
    }

    bool operator>=(const string& s1, const string& s2)
    {
        return !(s1 < s2);
    }

    bool operator==(const string& s1, const string& s2)
    {
        int ret = strcmp(s1.c_str(), s2.c_str());
        return ret == 0;
    }

    bool operator!=(const string& s1, const string& s2)
    {
        return !(s1 == s2);
    }

流插入：

    ostream& operator<<(ostream& out, const string& s)
    {
        for (auto e : s)
        {
            out << e;
        }
        return out;
    }

流提取：

    istream& operator>>(istream& in, string& s)
    {
        s.clear();
        char ch;
        ch = in.get();
        size_t i = 0;
        char buff[128];
        while (ch != ' ' && ch != '\0')
        {
            buff[i++] = ch;
            if (i == 127)
            {
                buff[127] = '\0';
                s += buff;
                i = 0;
            }
            ch = in.get();

        }
        if (i > 0)
        {
            buff[i] = '\0';
            s += buff;
        }
        return in;
    }

源代码：

#pragma once
#include<assert.h>
#include<iostream>
#include <string.h>

using namespace std;

namespace mystring
{
    class string

    {

        friend ostream& operator<<(ostream& _cout, const string& s);

        friend istream& operator>>(istream& _cin, bit::string& s);

    public:
        typedef char* iterator;
        typedef const char* const_iterator;


    public:

        const_iterator begin() const
        {
            return _str;
        }

        const_iterator end() const
        {
            return _str + _size;
        }

        iterator begin()
        {
            return _str;
        }

        iterator end()
        {
            return _str + _size;
        }

        const char* c_str()const
        {
            return _str;
        }


        string(const char* str = "")
            :_size(strlen(str))
        {
            _capacity = _size;
            _str = new char[_capacity + 1];
            strcpy(_str, str);

        }

        string(const string& s)
        {
            string tmp(s._str);
            swap(tmp);

        }

        string& operator=(string& s)
        {
            swap(s);
            return *this;
        }

        //string& operator=(const string& s)
        //{
        //    string tmp(s);
        //    swap(tmp);
        //    return *this;
        //}


        ~string()
        {
            delete[] _str;
            _str = nullptr;
            _size = _capacity = 0;
        }


        char& operator[](size_t index)
        {
            assert(index < _size);
            return _str[index];
        }

        const char& operator[](size_t index)const
        {
            assert(index < _size);
            return _str[index];
        }

        void swap(string& s)
        {

            std::swap(_str, s._str);
            std::swap(_size, s._size);
            std::swap(_capacity, s._capacity);
        }

        size_t find(char c, size_t pos = 0) const
        {
            assert(pos < _size);
            for (int i = pos; i < _size; i++)
            {
                if (_str[i] == c)
                    return i;
            }
            return npos;
        }

        size_t find(const char* sub, size_t pos = 0) const
        {
            assert(pos < _size);
            const char* p = strstr(_str + pos, sub);
            if (p)
                return p - _str;
            else
                return npos;
        }

        size_t size()const
        {
            return _size;
        }

        size_t capacity()const
        {
            return _capacity;
        }

        bool empty()const
        {
            return _str;
        }

        void resize(size_t n, char c = '\0')
        {
            if (n <= _size)
            {
                _str[n] = '\0';
                _size = n;
            }
            else
            {
                reserve(n);
                for (int i = _size; i < n; i++)
                {
                    _str[i] = c;
                }
                _str[n] = '\0';
                _size = n;

            }
        }

        void reserve(size_t n)
        {
            if (n > _capacity)
            {
                char* tmp = new char[n + 1];
                strcpy(tmp, _str);
                delete[] _str;
                _str = tmp;
                _capacity = n;
            }

        }

        void push_back(char c)
        {
            insert(_size, c);
        }

        string& operator+=(char c)
        {
            push_back(c);
            return *this;
        }


        string& operator+=(const char* str)
        {
            append(str);
            return *this;
        }


        void append(const char* str)
        {
            insert(_size, str);
        }

        void erase(size_t pos, size_t len = npos)
        {
            assert(pos < _size);
            if (pos == npos || len >= _size - pos)
            {
                _str[pos] = '\0';
                _size = pos;
            }
            else
            {
                strcpy(_str + pos, _str + pos + len);
                _size -= len;
            }
        }


        void insert(size_t pos, char c)
        {
            assert(pos <= _size);
            if (_size == _capacity)
                reserve(_capacity == 0 ? 4 : 2 * _capacity);

            size_t end = _size + 1;
            while (end > pos)
            {
                _str[end] = _str[end - 1];
                end--;
            }
            _str[pos] = c;
            ++_size;

        }

        void insert(size_t pos, const char* str)
        {
            assert(pos <= _size);
            size_t len = strlen(str);
            if (_size + len > _capacity)
            {
                reserve(_size + len);
            }
            size_t end = _size + len;
            while (end > pos + len - 1)//end - len +1 > pos
            {
                _str[end] = _str[end - len];
                end--;
            }
            strncpy(_str + pos, str, len);
            _size += len;
        }
        
        string substr(size_t pos = 0, size_t len = npos)
		{
			string sub;
			//if (len == npos || len >= _size-pos)
			if (len >= _size - pos)
			{
				for (size_t i = pos; i < _size; i++)
				{
					sub += _str[i];
				}
			}
			else
			{
				for (size_t i = pos; i < pos + len; i++)
				{
					sub += _str[i];
				}
			}

			return sub;
		}

        void clear()
        {
            _size = 0;
            _str[_size] = '\0';
        }

    private:
        char* _str = nullptr;
        size_t _size = 0;
        size_t _capacity = 0;
    public:
        static const int npos;
    };


    const int string::npos = -1;

    void swap(string& x, string& y)
    {
        x.swap(y);
    }

    bool operator==(const string& s1, const string& s2)
    {
        int ret = strcmp(s1.c_str(), s2.c_str());
        return ret == 0;
    }

    bool operator!=(const string& s1, const string& s2)
    {
        return !(s1 == s2);
    }


    bool operator<(const string& s1, const string& s2)
    {
        int ret = strcmp(s1.c_str(), s2.c_str());
        return ret < 0;
    }

    bool operator<=(const string& s1, const string& s2)
    {
        return s1 < s2 || s1 == s2;
    }

    bool operator>(const string& s1, const string& s2)
    {
        return !(s1 <= s2);
    }

    bool operator>=(const string& s1, const string& s2)
    {
        return !(s1 < s2);
    }


    ostream& operator<<(ostream& out, const string& s)
    {
        for (auto e : s)
        {
            out << e;
        }
        return out;
    }

    istream& operator>>(istream& in, string& s)
    {
        s.clear();
        char ch;
        ch = in.get();
        size_t i = 0;
        char buff[128];
        while (ch != ' ' && ch != '\0')
        {
            buff[i++] = ch;
            if (i == 127)
            {
                buff[127] = '\0';
                s += buff;
                i = 0;
            }
            ch = in.get();

        }
        if (i > 0)
        {
            buff[i] = '\0';
            s += buff;
        }
        return in;
    }

}

测试代码：

#define _CRT_SECURE_NO_WARNINGS 1
#include"string.h"

//void test_string1()
//{
//	string s1("hello world");
//	string s2;
//	cout << s1.c_str() << endl;
//	cout << s2.c_str() << endl;
//
//	for (size_t i = 0; i < s1.size(); i++)
//	{
//		s1[i]++;
//	}
//	cout << endl;
//
//	// s1[100];
//
//	for (size_t i = 0; i < s1.size(); i++)
//	{
//		cout << s1[i] << " ";
//	}
//	cout << endl;
//
//	const string s3("xxxx");
//	for (size_t i = 0; i < s3.size(); i++)
//	{
//		//s3[i]++;
//		cout << s3[i] << " ";
//	}
//	cout << endl;
//
//
//}

//void test_string2()
//{
//	string s3("hello world");
//	for (auto ch : s3)
//	{
//		cout << ch << " ";
//	}
//	cout << endl;
//
//	string::iterator it3 = s3.begin();
//	while (it3 != s3.end())
//	{
//		*it3 -= 1;
//		cout << *it3 << " ";
//		++it3;
//	}
//	cout << endl;
//
//	const string s4("xxxx");
//	string::const_iterator it4 = s4.begin();
//	while (it4 != s4.end())
//	{
//		*it4 += 3;
//		cout << *it4 << " ";
//		++it4;
//	}
//	cout << endl;
//
//	for (auto ch : s4)
//	{
//		cout << ch << " ";
//	}
//	cout << endl;
//}


//void test_string3()
//{
//	string s1("hello world");
//	cout << s1.c_str() << endl;
//
//	s1.erase(6, 3);
//	cout << s1.c_str() << endl;
//
//	s1.erase(6, 30);
//	cout << s1.c_str() << endl;
//
//	s1.erase(3);
//	cout << s1.c_str() << endl;
//
//	string s2("hello world");
//	cout << s2.c_str() << endl;
//
//	s2.resize(5);
//	cout << s2.c_str() << endl;
//
//	s2.resize(20, 'x');
//	cout << s2.c_str() << endl;
//}

//void test_string4()
//{
//	string s1("hello world");
//	cout << s1.c_str() << endl;
//
//	string s2(s1);
//	cout << s2.c_str() << endl;
//
//	s1[0] = 'x';
//
//	cout << s1.c_str() << endl;
//	cout << s2.c_str() << endl;
//
//	string s3("xxxxx");
//	s1 = s3;
//
//	cout << s1.c_str() << endl;
//	cout << s3.c_str() << endl;
//}

void test_string5()
{
	string s1("hello world");
	cout << s1.c_str() << endl;

	s1.insert(6, "xxx");
	cout << s1.c_str() << endl;

	string s2("xxxxxxx");

	cout << s1.c_str() << endl;
	cout << s2.c_str() << endl;
	swap(s1, s2);
	s1.swap(s2);
	cout << s1.c_str() << endl;
	cout << s2.c_str() << endl;
}

int main()
{

	test_string5();


	return 0;
}

深情汤姆
关注
C++ string类的模拟实现
08-11
C++ string类的模拟实现
如何实现一个string类(1)
Vincent的专栏
03-04 2432
string类是C++当中用的非常频繁的一个类，它提供了很多处理字符串的函数，让字符串的使用变得像int、float等built-in类型一样简单。string类的实现包含了大量c++语言的知识，其中有很多值得讨论的问题。自己动手实现一个string类是学习c++语言的好方法，可以检验自己一下C++基础知识掌握的如何。下面我们来尝试动手实现一个字符串类。 1.定义成员变量 我们的字符串类需要处理...
字符串类的实现
最新发布
weixin_74154228的博客
05-02 1510
在《字符串类的实现 2》的基础上，增加 myString字符串类 的方法：重载运算符 << ：先输出 len ，然后一个空格，一个冒号，再一个空格，然后输出 data 所指字符数组。如果不含字符，则只输出一个 0。重载运算符 >> ：读入字符串，存入 data 所指字符数组。注意：读入的一行字符串长度可能很大，建议先读入到一个 string 对象后再处理。第一行是一个正整数 n，接下来 n 行，每行一个字符串，字符串中不含空格。注意：可能含有空行，即长度为 0 的空字符串。
string类的实现
m0_72532428的博客
10-02 1165
string类构造函数的实现 1.构造函数的实现 使用**“”**空字符串作为缺省参数，常量字符串末尾有‘\0’，当不传参时，_str只存着一个‘\0’ 拷贝构造函数的实现 这里的tmp变量属于局部变量，当拷贝构造函数调用完以后栈帧会销毁，tmp变量也会跟着销毁了。 注意：同一个类域中，类的成员变量可以相互访问 string类c_str函数实现 返回字符串指针（该字符串的首地址） string类size函数的实现 _size为私有成员变量，在类域外需要通过函数才能调用进行间接访问 string类cap
MyString（字符串类）实现
hdlwyt的博客
01-16 4595
一、MyString类的组成 1.1 私有成员 char* data 字符型指针 int length 整型字符串长度 1.2 共有成员 1.2.1 构造与析构函数 MyString() 默认构造 MyString(const int intNum) 整数构造 MyString(const float floatNum) 浮点数构造 MyString(const char* pStr) 一般构造 MyString(const int* pStr) 整型bu...
实现简单String类
vgxpm的专栏
07-23 762
1、实现String类，关键是重载赋值运算符的解法，下面先分析赋值运算符函数的关键点： 1）是否把返回值的类型声明为该类型的引用； 2）是否把传入的参数的类型声明为常量引用，若传入的参数不是引用而是实例，则从形参到实参会调用一次复制构造函数，而声明为const，是保证不改变实参； 3）在赋值新值之前，是否释放实例自身之前已有的内存，否则容易出现内存泄漏； 4）是否判断传入的参数和当前实例是
C++中string类的模拟实现
02-23
该资源中模拟实现了C++中string类的一些常用接口，包括resize、reserve、insert、erase等等，重载了流插入和流提取操作符以实现对string类对象的输出和输入。其中还关注了深拷贝的问题（由于string类中涉及内存资源...
详解C++中String类模拟实现以及深拷贝浅拷贝
12-31
详解C++中String类模拟实现以及深拷贝浅拷贝 在C语言中/C++中，字符串是一个应用很广泛的类型，也是很基础的类型，C语言并没有直接处理字符串的操作而是采用字符指针和字符串数组进行操作，而在C++中标准库为我们...
C++使用动态内存分配,自己实现一个字符串类，并编写main函数测试该类
qq_64296768的博客
08-22 180
使用动态内存分配,自己实现一个字符串类，并编写main函数测试该类。
C++自己实现的字符串类
04-23
自己实现的字符串类 class CMStringImp; class CMstring { public: explicit CMstring(void); ~CMstring(void); CMstring(LPCTSTR lpszstr); CMstring(const CMstring& lpszstr); CMstring& operator = (const CMstring& lpszstr); operator LPCTSTR() const; bool operator == (const CMstring&) const; bool operator != (const CMstring&) const; bool operator < (const CMstring&) const; TCHAR operator[] (int nIndex) const; TCHAR& operator[] (int nIndex); CMstring& operator += (LPCTSTR pStr); CMstring& operator += (TCHAR ch); friend CMstring operator+(const CMstring& str1, const CMstring& str2); friend CMstring operator+(const CMstring& str1, LPCTSTR lpszstr); friend CMstring operator+(const CMstring& str1, TCHAR ch); friend CMstring operator+(TCHAR ch, const CMstring& str1); friend CMstring operator+(LPCTSTR lpszstr, const CMstring& str1); // friend wostream operator <<(wostream &is;,const CMstring &str;); public: LPCTSTR GetData() const; bool IsEmpty() const; TCHAR GetAt(int) const; TCHAR& GetAt(int); int GetLength() const; int Compare(const CMstring&) const; int CompareNoCase(const CMstring&) const; int Find(TCHAR ch, int nStart = 0) const; int Find(LPCTSTR pStr, int nStart = 0) const; int ReverseFind(TCHAR ch) const; int ReverseFind(LPCTSTR pStr) const; CMstring Right(int nCount) const; CMstring Left(int nCount ) const; public: CMstring& MakeLower(); CMstring& MakeUpper(); CMstring& MakeReverse(); int Replace(TCHAR chOld, TCHAR chNew); int Replace(LPCTSTR pszOld, LPCTSTR pszNew); int Insert(int iIndex, TCHAR ch); void Format(LPCTSTR lpszFormat, ...); private: CMStringImp* m_pImp; };
用C++实现的一个简单的字符串类
10-13
用C++实现的一个简单的字符串类 解压直接可运行的一个VS2008的工程文件
字符串的连接(C++)
weixin_50192397的博客
12-27 8922
不用字符串处理函数将两个字符串连接，即将字符串b连接到字符串a的后面，变成字符串c。 #include<iostream> #include<string> using namespace std; int main() { string a; string b; string c; cout << "请输入字符串a:"; cin >> a; cout << "请输入字符串b:"; cin >> b; c = a + b
#P0979. [CSP-J 2021] 网络连接
m0_69379426的博客
02-01 420
这道题真的有点恶心，一道大模拟！！可以看到模拟题的题意还是非常长的，所以这时候一定要看清题意再去动手做题，不然有可能某个模块写到一半发现下面的要求跟你写的有点不对，改的麻烦是一回事，搞心态才是重点！！处理模块如上：（介绍几个方法）1、sscanf(char[],string格式化字符串,保存的变量.....);这个函数会返回读入了几个合法变量；比如int t = sscanf(“20140523”,“%4d%2d%2d”,&y,&m,&d);此时三个变量都合法那么t = 3;
实现一个字符串类
MeetingParis的博客
03-27 1617
//MyString.h#include &lt;iostream&gt; using namespace std; //c中没有字符串 字符串类(c风格的字符串) //空串 "" class MyString { friend ostream&amp; operator&lt;&lt;(ostream &amp;out, MyString &amp;s); friend istream&...
C++ 自己动手简单实现字符串String类
魔筝炼药师
03-29 4868
实现一个自己的String类是一道考验C++基础知识的好题。能够准确无误地编写出String类的构造函数、拷贝构造函数、赋值函数和析构函数的面试者至少已经具备了C++基本功的60%以上！ 在这个类中包括了指针类成员变量m_pData，当类中包括指针类成员变量时，一定要重载其拷贝构造函数、赋值函数和析构函数，这既是对C++程序员的基本要求，也是《Effective　C++》中特别强调的条款。 仔...
字符串类的简单实现! (完成部分功能)
花言的博客
05-18 353
strarr.h #pragma once #define _CRT_SECURE_NO_WARNINGS #include <iostream> #include <string> using namespace std; class strarr { public: //字符串长度 int getstrsize(); //重载=运算符 strarr& operator=(strarr& str); //地址传递 strarr& op.
实现一个最基本的String类【C++】
majichen95的博客
07-20 590
题目： 实现String类的构造函数、析构函数并重载赋值操作符。 解答： class String{ public: String(); String(const char *pStr); String(const String &amp;str); String &amp;operator=(const String &amp;str); vi...
实现一个string类
dongkai0918的博客
09-22 252
需要实现的基本功能：构造函数、拷贝构造函数、赋值函数、析构函数. (以前合称big three, 现在叫做copy control) 1 class String { 2 public: 3 String(const char* str = ""); 4 String(const String& rhs); 5 ~Strin...
C++模拟实现String类基础功能详解
"C++中的String类是一个非常常用的数据结构，用于处理文本字符串。本文将探讨如何简单地实现一个基础版的String类，虽然不能与标准库中的std::string完全相同，但足以涵盖一些核心功能，如构造函数、拷贝构造函数、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值