#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`的一些基本功能概述。每个函数都有其特定的用途，在不同的场景下选择合适的函数可以有效地管理和操作数据．
