自定义string类

最新推荐文章于 2024-09-16 17:46:36 发布

向日葵．

最新推荐文章于 2024-09-16 17:46:36 发布

阅读量952

点赞数 24

文章标签： c++ 算法开发语言

本文链接：https://blog.csdn.net/qq_33089547/article/details/141939456

版权

#include <iostream>  
#include <string>  
  
int main() {  
    std::string str = "Hello, World!";  
  
    // 使用 c_str() 将 std::string 转换为 C 风格字符串，并传递给 printf  
    printf("The string is: %s\n", str.c_str());  
  
    // 尝试修改返回的 C 风格字符串（错误示例，不应这样做）  
    // char* cstr = str.c_str();  
    // cstr[0] = 'h'; // 未定义行为，因为 cstr 指向的内存是常量  
  
    return 0;  
}

#include <iostream>
#include <string.h>
#include <cstring>
using namespace std;
class String {
public:
    String();
    String(const char *pstr);
    String(const String& rhs);
    String &operator=(const String &rhs);
    ~String();

    void print();
    size_t length() const;
    const char* c_str() const;

private:
    char *_pstr;
};

String::String() : _pstr(new char[1]) {
    _pstr[0] = '\0'; // 初始化为空字符串
}
String::String(const char *pstr) : _pstr(new char[strlen(pstr) +1]) {
    strcpy(_pstr,pstr);
}

String::String(const String& rhs) : _pstr(new char[strlen(rhs._pstr) + 1]) {
    strcpy(_pstr, rhs._pstr);
}
String& String::operator=(const String &rhs) {
    if (this != &rhs) {
        delete[] _pstr; // 释放旧资源
        _pstr = new char[strlen(rhs.c_str()) + 1]; // 分配新资源
        strcpy(_pstr, rhs.c_str()); // 复制内容
    }
    return *this; //String(const String& rhs) 返回对象的引用
}
const char* String::c_str() const {
    return this->_pstr;
}
size_t String::length() const {
    return strlen(_pstr);
}
void String::print() {
    std::cout << _pstr << std::endl;
}
String::~String() {
    if (_pstr) {
        delete[] _pstr;
    }
}


int main(){
    String str1("123");
    str1.print();

}


int main() {
	String str1("123");
	str1.print();
	std::cout << str1.length() << std::endl;
	return 0;
}

#include <iostream>
#include <vector>

template<typename T>
class SimpleStack {
public:
    // 添加元素到栈顶
    void push(T&& item) {
        data_.emplace_back(std::forward<T>(item));
    }

    // 移除栈顶元素并返回它的值
    T pop() {
        if (data_.empty()) {
            throw std::out_of_range("pop from empty stack");
        }
        T topItem = std::move(data_.back());
        data_.pop_back();
        return topItem;
    }

    // 返回栈顶元素，不移除
    const T& top() const {
        if (data_.empty()) {
            throw std::out_of_range("top from empty stack");
        }
        return data_.back();
    }

    // 检查栈是否为空
    bool empty() const {
        return data_.empty();
    }

    // 返回栈中的元素数量
    size_t size() const {
        return data_.size();
    }

private:
    std::vector<T> data_; // 使用std::vector作为底层容器存储数据
};

// 测试SimpleStack功能的小程序
int main() {
    SimpleStack<int> intStack;
    intStack.push(1);
    intStack.push(2);
    intStack.push(3);

    std::cout << "Top element is: " << intStack.top() << std::endl;
    std::cout << "Popped element is: " << intStack.pop() << std::endl;
    std::cout << "New top element is: " << intStack.top() << std::endl;

    return 0;
}

这个push函数的设计利用了C++11引入的右值引用（rvalue reference）和完美转发（perfect forwarding）技术。让我们一步一步来看这个函数的细节：

void push(T&& item) {
    data_.emplace_back(std::forward<T>(item));
}

1. **右值引用 (Rvalue Reference)**:
- `T&& item` 这个声明表示`item`是一个右值引用，它可以绑定到一个右值（即临时对象）或者一个左值（普通的命名对象）。右值引用的存在主要是为了支持移动语义（move semantics），使得我们可以更高效地处理临时对象而不必进行拷贝构造。

2. **完美转发 (Perfect Forwarding)**:
- `std::forward<T>(item)` 这个函数的作用是完美地将`item`转发给`data_.emplace_back`。如果`item`是一个右值（例如，当`push`被调用时传递了一个临时对象），`std::forward`会保留其右值性质；如果`item`是一个左值，那么它会被转发为左值。
- 这种技术被称为“完美转发”，因为它允许我们将`push`函数的参数原封不动地传递给`emplace_back`，无论这个参数最初是以何种形式传递给`push`的。

3. **`emplace_back`**:
- `std::vector` 类的一个成员函数，它在容器尾部直接构造一个新的元素。这比使用`push_back`更高效，因为`push_back`通常需要先创建一个临时对象再将其移动到容器中，而`emplace_back`则是在容器中直接构造对象，省去了临时对象的创建和移动。

为什么这么做？

- **性能**: 对于那些具有昂贵拷贝构造函数的对象，或者当传递的对象是临时对象时，使用右值引用和完美转发可以避免不必要的拷贝，从而提高性能。
- **灵活性**: 它使得函数能够接收任意类型的对象——无论是临时对象还是已经存在的对象——并且以最有效的方式处理它们。

总的来说，这种设计方式让我们的`push`函数更加通用且高效，尤其是在处理大型对象或者资源密集型对象时。

vector常用的函数：

`std::vector` 是C++标准库中的一个非常强大的容器，用于存储动态大小的数据集合。它提供了许多实用的成员函数，这些函数可以帮助我们方便地管理数据。下面是一些`std::vector`常用的成员函数及其用途简介：

1. **构造与初始化**
- `vector()`: 默认构造函数，创建一个空的`vector`。
- `vector(n, val)`: 创建一个含有`n`个`val`值的`vector`。
- `vector(const vector& v)`: 复制构造函数，创建一个与`v`相同的新`vector`。
- `vector(std::initializer_list<value_type> il)`: 使用一个初始化列表来初始化`vector`。

2. **容量**
- `size()`: 返回`vector`中的元素数量。
- `empty()`: 如果`vector`为空，则返回`true`。
- `max_size()`: 返回`vector`可能达到的最大大小。
- `capacity()`: 返回当前`vector`的容量，即它可以容纳的元素数量。
- `reserve(size_type new_cap)`: 请求改变`vector`的容量，使其至少为`new_cap`。

3. **元素访问**
- `operator[]`: 使用索引来访问元素。
- `at(size_type pos)`: 访问指定位置的元素，并检查索引是否越界。
- `front()`: 访问第一个元素。
- `back()`: 访问最后一个元素。
- `data()`: 返回指向容器中第一个元素的指针。

4. **修改器**
- `push_back(const value_type& val)`: 在`vector`末尾添加一个元素。
- `emplace_back(Args&&... args)`: 在`vector`末尾直接构造一个元素。
- `pop_back()`: 移除最后一个元素。
- `insert(iterator position, const value_type& val)`: 在`position`前插入一个元素。
- `insert(iterator position, n, val)`: 在`position`前插入`n`个`val`值。
- `insert(iterator position, std::initializer_list<value_type> il)`: 使用初始化列表来插入元素。
- `erase(iterator position)`: 删除`position`所指向的元素。
- `erase(iterator first, iterator last)`: 删除`[first, last)`区间内的元素。
- `assign(std::initializer_list<value_type> il)`: 使用初始化列表重置`vector`的内容。
- `clear()`: 移除所有元素。

5. **交换与释放**
- `swap(vector& v)`: 与另一个`vector`交换内容。
- `shrink_to_fit()`: 尝试减小`vector`的容量以匹配它的大小。

6. **分配器**
- `allocator_type get_allocator()`: 返回`vector`使用的分配器。

7. **迭代器**
- `begin()` 和 `end()`: 返回指向`vector`开始和结束位置的迭代器。
- `cbegin()` 和 `cend()`: 返回指向`vector`开始和结束位置的常量迭代器。
- `rbegin()` 和 `rend()`: 返回指向`vector`反向开始和结束位置的逆向迭代器。
- `crbegin()` 和 `crend()`: 返回指向`vector`反向开始和结束位置的常量逆向迭代器。

以上就是`std::vector`的一些基本功能概述。每个函数都有其特定的用途，在不同的场景下选择合适的函数可以有效地管理和操作数据．