MyString 类 构造函数 对象行为 设计模式 单例模式

系列文章目录

---

---

前言

记录不同行为的拷贝与构造情况。

---

一、MyString类

string

简单的string类实现

• 不支持模板定制，仅支持char字符串类型，不支持自定义分配器等，没有basic_string模板类

class string
{
private:
    unsigned len;
    char* pbuf;
public:
    string();
    explicit string(const char* str);
    string(const string&);
    ~string();
    string& operator=(const string&);
    string& operator=(const char* s);
    const char& operator[](unsigned idx) const;
    char& operator[](unsigned idx);
    const char* c_str() const;
    unsigned length() const;
    unsigned size() const;
};
string::string(): len(0), pbuf(nullptr) {}
string::string(const char* str)
{
    len = strlen(str);
    pbuf = strcpy(new char[len+1], str);
}
string::string(const string& s): len(0), pbuf(nullptr)
{
    *this = s;
}
string::~string()
{
    if (pbuf != nullptr) {
        delete[] pbuf;
        pbuf = nullptr;
        len = 0;
    }
}
string& string::operator=(const string& s)
{
    if (&s == this) return *this;
    this->~string();
    len = s.len;
    pbuf = strcpy(new char[len+1], s.pbuf);
    return *this;
}
string& string::operator=(const char* s)
{
    this->~string();
    len = strlen(s);
    pbuf = strcpy(new char[len+1], s);
    return *this;
}
const char& string::operator[](unsigned idx) const
{
    return pbuf[idx];
}
char& string::operator[](unsigned idx)
{
    return pbuf[idx];
}
const char* string::c_str() const
{
    return pbuf;
}
unsigned string::length() const
{
    return len;
}
unsigned string::size() const
{
    return len;
}

二、构造函数的各种重载形式

编译器根据实例化对象时传入的参数类型选择对应形式的构造函数

MyString();
MyString(const char*);
MyString(const MyString&);

根据一个已存在的对象初始化新对象时调用拷贝构造
如函数，MyString fun(MyString str); 在传递参数和函数返回时调用拷贝构造

MyString s1;       // 默认构造
MyString s2 = s1;  // 拷贝构造

operator=的安全定义参见：https://blog.csdn.net/surfaceyan/article/details/125586372

三、多线程下的对象行为

非静态成员函数

    MyString s1;
    // MyString s2 = s1;
    std::thread thd(&MyString::memberfn, &s1);  // non-static 成员函数必须带&, 非静态成员函数的第一个参数为 decltype(this)
    thd.join();

默认构造 MyString() | this = 0x7fffb8746b68 | thread_id: 140645677708224
成员函数 memberfn   | this = 0x7fffb8746b68 | thread_id: 140645670843968
析构 ~MyString()   | this = 0x7fffb8746b68 | thread_id: 140645677708224

单例模式

1. 懒汉式

// 1)静态指针+用到时初始化  2)局部静态变量
/// @brief 延时加载，如配置文件，当用到时才实例化对象
// 在单线程中，这样的写法是可以正确使用的，但是在多线程中就不行了，该方法是线程不安全的。
class SingleTon
{
private:
    SingleTon(/* args */) = default;
    ~SingleTon() = default;
public:
    SingleTon(const SingleTon&) = delete;
    SingleTon& operator=(const SingleTon&) = delete;

    static SingleTon& GetInstance()
    {
        if (!value_) {
            value_ = new SingleTon();
        }
        return *value_;
    }
private:
    static SingleTon* value_;
public:
    int a = 0;
};
SingleTon* SingleTon::value_ = nullptr;
/// @brief 线程不安全
class SingleTon2
{
public:
    SingleTon2(const SingleTon2&) = delete;
    SingleTon2& operator=(const SingleTon2&) = delete;

    static SingleTon2& GetInstance()
    {
        static SingleTon2 value;
        return value;
    }
private:
    SingleTon2(/* args */) = default;
    ~SingleTon2() = default;
};

2. 饿汉式

// 1)直接定义静态对象  
// 线程安全
class SingleTon3
{
public:
    SingleTon3(const SingleTon3&) = delete;
    SingleTon3& operator=(const SingleTon3&) = delete;

    static SingleTon3& GetInstance()
    {
        return instance;
    }
private:
    static SingleTon3 instance;
    SingleTon3(/* args */) = default;
    ~SingleTon3() = default;
};
SingleTon3 SingleTon3::instance;  // instance = SingleTon3()

// 2）静态指针+类外初始化时new空间实现
class SingleTon4
{
public:
    SingleTon4(const SingleTon4&) = delete;
    SingleTon4& operator=(const SingleTon4&) = delete;
    
    static SingleTon4& GetInstance()
    {
        return *instance_ptr;
    }
private:
    static SingleTon4* instance_ptr;
    SingleTon4() = default;
    ~SingleTon4() = default;
};
SingleTon4* SingleTon4::instance_ptr = new SingleTon4();

总结

静态的对象或者静态的指针，类内创建或类外创建

---

总结

略