#include <iostream>
#include <memory>
using namespace std;
class Singleton
{
public:
static Singleton* GetInstance()
{
// if (instance_ == nullptr)
// {
// instance_ = new Singleton;
// }
// return instance_;
if(!instance_.get())
{
instance_ = auto_ptr<Singleton>(new Singleton);
}
return instance_.get();
}
~Singleton()
{
cout << "~Singleton ..." << endl;
}
private:
// 禁止拷贝（只有声明，没有实现，要是有拷贝的操作，会直接报错）
Singleton(const Singleton& other);
Singleton& operator=(const Singleton& other);
// 拷贝构造声明为私有，外部就不能构造对象
Singleton()
{
cout << "Singleton ..." << endl;
}
// static Singleton* instance_; // 这边使用智能指针，不然就必须手动释放instance_，在项目中，可能有很多地方调用，这样就很难控制在哪释放
static auto_ptr<Singleton> instance_;
};
auto_ptr<Singleton> Singleton::instance_;
int main() {
Singleton* s1 = Singleton::GetInstance();
Singleton* s2 = Singleton::GetInstance();
std::cout << "Hello, World!" << std::endl;
return 0;
}
// 输出
Singleton ...
Hello, World!
~Singleton ...
Noncopyable继承注意要点
class Noncopyable
{
protected:
Noncopyable() {}
~Noncopyable() {}
private:
Noncopyable(const Noncopyable&);
const Noncopyable& operator=(const Noncopyable&);
};
class Parent : private Noncopyable
{
public:
// 默认构造函数中，即使后面没有加上:Noncopyable()，也会自动调用基类的默认构造函数。但是拷贝构造函数就不一样。
// 如果加上了: Noncopyable()，则基类必须要有: Noncopyable()的声明
Parent() : Noncopyable()
{
}
// 当你自己又重新定义了拷贝构造函数，则不会去调用基类的拷贝构造函数，这样基类的私有拷贝就会失效。这样就会被拷贝出来。
// 所以这样的拷贝构造是不符合规范的
// Parent(const Parent& other)
// {
//
// }
// 下面是符合规范的拷贝构造函数（这样才能实现禁止拷贝）
Parent(const Parent& other) : Noncopyable(other)
{
}
};
class Child : public Parent
{
};
int main() {
Parent p1;
Parent p2(p1); // 要调用拷贝构造函数，Parent构造函数又调用Noncopyable的拷贝构造函数（私有且没有实现，所以会报错）
// Child c1;
// Child c2(c1); // 也是同上的道理
return 0;
}
自定义sizeof和内存对齐
#include <iostream>
using namespace std;
// 大小的宏
// 两个指针相减，得到的是相隔几个元素
#define sizeof_v(x) (char*)(&x+1) - (char*)(&x)
#define sizeof_t(t) ((size_t)((t*)0 + 1))
// 对齐
#define ALIGN(v, b) ((v+b-1) & ~(b-1))
class Empty
{
};
int main() {
Empty e;
int n;
cout << sizeof_v(e) << endl;
cout << sizeof_v(n) << endl;
cout << sizeof_t(Empty) << endl;
cout << sizeof_t(int) << endl;
cout << ALIGN(3, 16) << endl;
cout << ALIGN(31, 16) << endl;
cout << ALIGN(0, 16) << endl;
cout << ALIGN(4198, 4096) << endl;
return 0;
}
// 输出
1
4
1
4
16
32
0
8192
