string模拟优化和vector使用

 1.简单介绍编码

utf_8变长编码，常用英文字母使用1个字节，对于其它语言可能2到14，大部分编码是utf_8，char_16是编码为utf_16,     char_32是编码为utf_32，   wchar_t是宽字符的，

utf_16是大小为俩个字节，所以牛马还有一个'\0'一个是3*2六个字节

utf_32是大小为四个字节所以大小就是3*4十二个字节

wchar_t 在window上通常为2字节，其它环境有不同大小。

	char16_t str16[] = u"牛马";char32_t str32[] = U"牛马";wchar_t wstr[] = L"牛马";cout << sizeof(str) << endl;cout << sizeof(str16) << endl;cout << sizeof(str32) << endl;cout << sizeof(wstr) << endl;*/

 2.对于拷贝优化

省略的部分是可以用上面的代替，先构造一个tmp出来，然后把s1复制到tmp上，再去交换s2和tmp，这里是浅拷贝了指针，如果不用交换而是直接把指针值复制过去会有野指针的问题，因为另一个被复制的变量如果被销毁了，那么它指向的空间也会被收回，浅拷贝是一个一个字节复制的，所以此时还剩一个变量指向被释放的空间就会有问题，而swap可以很好的解决，交换完后tmp销毁了，但是销毁的是s1的空间。

void test_string6(){string s1("hello world");string s2 = s1;cout << s1 << endl;cout << s2 << endl;string s3("xxxxxxxxxxxxxx");s1 = s3;cout << s1 << endl;cout << s3 << endl;}

	string(const char* str = ""){_size = strlen(str);// _capacity不包含\0_capacity = _size;_str = new char[_capacity + 1];strcpy(_str, str);}string(const string& s){string tmp(s._str);swap(tmp);}// 深拷贝问题// s2(s1)/*string(const string& s){_str = new char[s._capacity + 1];strcpy(_str, s._str);_size = s._size;_capacity = s._capacity;}*/void swap(string& s){std::swap(_str, s._str);std::swap(_size, s._size);std::swap(_capacity, s._capacity);}

 

 

3.赋值运算符重载

先判断是否相等，是则直接结束，不一样就构造tmp并拷贝，然后交换，这里的if除了判断是否一样还有其它作用，{}符号表明了一个局部作用域，所以局部变量在出了这个{}会被销毁，tmp就会被销毁，一举两得。

	 //s1 = s3;string& operator=(const string& s){if (this != &s){//string tmp(s._str);string tmp(s);swap(tmp);}return *this;}

下面是进一步优化

在形参数部分变为string tmp，这样s3作为参数时，先构造tmp然后指向拷贝构造，这里swap只写tmp是因为还有一个隐式参数*this，所以交换，除了{}tmp销毁，代码简洁性高。

	// s1 = s3;string& operator=(string tmp){swap(tmp);return *this;}

 

 4.swap

可以看到模板的swap是先拷贝c，然后在赋值运算符重载俩次，注意如果a和b都有指向资源，那么就要用深拷贝，那么一次swap就三次深拷贝，是非常占资源的，所以用上面的就相对效率高，如果字节的类里面有,这里的std::swap调用的却是全局的swap，全局的swap效率高于模板swap(std::swap)，而且有实例化的swap也不会去模板生成swap。是因为编译器会去找最适配的swap，就像你像吃辣条，你的妈妈却还是给你买健康的食品。

 5.简单介绍引用计数和写时拷贝

引用计数：在加一个变量来记录有多少个指针指向这个空间，这样就有判断的标准，如果大于1就是有多个指向这块空间，等于一就说明只有一个指针指向这里，可以自由修改，也不会有多次析构。

写时拷贝：

写时拷贝是一种优化技术，通常用于减少内存使用和提高性能。它允许多个对象共享同一份数据，直到有一个对象需要修改这份数据为止。只有在需要修改时，才会进行数据的实际拷贝，从而避免不必要的内存分配和复制操作

6.vector简单使用

 1.创建vector

创建俩个vector变量，vector是stl的模板要显式实例化，可以看到不写参数是走缺省参数的，而10，1就是10个int的元素，值为1。

用reserve(域string的作用一样，提前开空间)，可以看到比原来大会改变，再改小则不会变化。

	vector<int> v2(10, 1);v2.reserve(15);cout << v2.size() << endl;cout << v2.capacity() << endl;v2.reserve(25);cout << v2.size() << endl;cout << v2.capacity() << endl;v2.reserve(5);cout << v2.size() << endl;cout << v2.capacity() << endl;

2.使用resize

resize函数会改变vector实例对象的大小，当为5时就只有五个在vector里面，

 

这里是如果扩大则会填充第二个参数，一开始是10个1，后面变成15，则再填5个2，25就再填10个3. 

void test_vector3()
{//TestVectorExpand();vector<int> v(10, 1);v.reserve(20);cout << v.size() << endl;cout << v.capacity() << endl;v.resize(15, 2);cout << v.size() << endl;cout << v.capacity() << endl;v.resize(25, 3);cout << v.size() << endl;cout << v.capacity() << endl;v.resize(5);cout << v.size() << endl;cout << v.capacity() << endl;
}

 

 

 

3.二维的vector 

先初始化一个一维的v，然后以v为参数构造二维的vv，

vector<int> v(10, 1);vector<vector<int>> vv(5,v);

 

4.迭代器和范围for遍历vector

这里前置++和前置--则最后只有八位打印出来，因为是从begin后一位和end前一位，循环和范围for也可以逐个打印，像之前的数组一样。 

 

void test_vector1()
{vector<int> v1;vector<int> v2(10, 1);vector<int> v3(++v2.begin(), --v2.end());for (size_t i = 0; i < v3.size(); i++){cout << v3[i] << " ";}cout << endl;vector<int>::iterator it = v3.begin();while (it != v3.end()){cout << *it << " ";++it;}cout << endl;for (auto e : v3){cout << e << " ";}cout << endl;
}

 

 5.vector的操作

insert是在vector中插入数据，前一个是位置，后一个是插入什么元素，后面用for来cin初始化vector。

	vector<int> v(10, 1);v.push_back(2);v.insert(v.begin(), 0);for (auto e : v){cout << e << " ";}cout << endl;v.insert(v.begin() + 3, 10);for (auto e : v){cout << e << " ";}cout << endl;vector<int> v1(5, 0);for (size_t i = 0; i < 5; i++){cin >> v1[i];}for (auto e : v1){cout << e << ",";}cout << endl;

 

前面知识补充：

在 C++ 中，可以使用强制转换将指针类型转换为 void*，这是合法的，且在某些情况下非常有用。下面，我将详细解释如何在 C++ 中使用 void*，以及在与 std::cout 结合使用时的注意事项。
1. 强制转换为 void*
在 C++ 中，任何指针类型都可以被隐式或显式转换为 void*。void* 是一种通用指针类型，能够指向任何类型的数据。通过这种转换，你可以在不知道指针具体类型的情况下处理内存地址。这在处理底层内存操作或需要泛型编程的情况下特别有用。
2. 与 std::cout 的结合使用
如你所述，std::cout 对 const char* 类型进行了特别的处理，重载了 << 运算符以打印字符串的内容。如果你需要打印 const char* 的地址，可以使用 (void*) 来强制转换：
std::cout << (void*)cStr;

这将输出指针的内存地址，而不是它指向的字符串内容。
3. 示例代码
以下是一个完整的示例代码，演示了如何使用 void* 强制转换以及打印字符串内容和指针地址的区别：
#include <iostream>
#include <string>

int main() {
    std::string str = "Hello, World!";
    const char* cStr = str.c_str();

    // 输出字符串内容
    std::cout << "内容: " << cStr << std::endl;  // 输出: Hello, World!

    // 输出指针的地址
    std::cout << "指针地址: " << (void*)cStr << std::endl;  // 输出: 指针的内存地址

    return 0;
}

4. 输出结果
运行上述代码时，输出将类似于：
内容: Hello, World!
指针地址: 0x7ffee6b7c3d0  // 这个值会因每次运行而不同

5. 关键点总结

1.重载运算符：std::cout 对 const char* 类型的重载实现允许直接输出字符串内容。
2.地址输出：如果你想输出指针的地址，必须使用 (void*) 来进行强制转换。
3.合法性：使用强制转换 void* 是合法的，可以用于指针类型与通用指针之间的转换。

6. 注意事项
虽然强制转换为 void* 是合法的，但在某些情况下需要谨慎使用：

4.类型安全：使用 void* 可能会导致类型安全问题，尤其是在进行指针运算时。
5.需要显式转换回原始类型：在使用 void* 时，如果需要再次使用原始类型的指针，你必须显式地将其转换回来，这可能会引入错误。

总的来说，使用 void* 是 C++ 中一种灵活的指针处理方式，但要注意相应的安全性和可读性问题。

在 C++ 中，std::string 类提供了 replace 函数，用于替换字符串中的部分内容。这个函数可以使用不同的参数形式，允许你根据需求替换子字符串或单个字符。
std::string::replace 函数的基本用法
1. 替换子字符串
使用 std::string::replace 来替换指定范围内的字符，可以按以下方式调用：
std::string& replace(size_t pos, size_t len, const std::string& str);

1.pos：要替换的起始位置。
2.len：要替换的字符数。
3.str：用于替换的字符串。

示例代码：
#include <iostream>
#include <string>

int main() {
    std::string str = "Hello, world!";

    // 从位置 7 开始替换 5 个字符
    str.replace(7, 5, "C++");

    std::cout << str << std::endl; // 输出: Hello, C++!
    return 0;
}

2. 替换单个字符
std::string::replace 也可以用来替换单个字符，示例如下：
std::string& replace(size_t pos, size_t len, size_t n, char c);

4.n：替换字符的数量。
5.c：要替换成的字符。

示例代码：
#include <iostream>
#include <string>

int main() {
    std::string str = "Hello, world!";

    // 从位置 7 开始替换 5 个字符为字符 '*'
    str.replace(7, 5, 3, '*');

    std::cout << str << std::endl; // 输出: Hello, ***d!
    return 0;
}

3. 替换另一个字符串
你还可以用另一个字符串的子串来替换当前字符串中的部分内容：
std::string& replace(size_t pos, size_t len, const char* s);

示例代码：
#include <iostream>
#include <string>

int main() {
    std::string str = "Hello, world!";

    // 从位置 7 开始替换 5 个字符为 C 风格字符串 "C++"
    str.replace(7, 5, "C++");

    std::cout << str << std::endl; // 输出: Hello, C++!
    return 0;
}

4. 替换多个字符
如果需要替换多个字符，可以使用 std::string::replace 结合字符串的长度来实现：
#include <iostream>
#include <string>

int main() {
    std::string str = "Hello, world! Hello, world!";

    // 替换所有 "world" 为 "C++"
    size_t pos = 0;
    std::string to_replace = "world";
    std::string replace_with = "C++";

    while ((pos = str.find(to_replace, pos)) != std::string::npos) {
        str.replace(pos, to_replace.length(), replace_with);
        pos += replace_with.length(); // Move past the replaced part
    }

    std::cout << str << std::endl; // 输出: Hello, C++! Hello, C++!
    return 0;
}

总结
std::string::replace 是一个强大的工具，可以灵活地对字符串中的部分内容进行替换。根据需要，可以选择替换字符、字符串或使用 C 风格字符串。通过适当的循环和查找，可以实现更复杂的替换操作。