重载"="运算符，实现异常安全的

#ifndef WIDGET_H#define WIDGET_H#include <iostream>using namespace std;class Widget{public: Widget(int* elem); ~Widget(){delete _elem;cout<<"~~~"<<endl;} Widget(const Widget& co); Widget& operator=(const Widget& co); void swap(Widget& co); void show() const{cout<<*_elem<<endl;}private: int* _elem;};
#endif // WIDGET_H#include "widget.h"
Widget::Widget(int *elem):_elem(elem){ }Widget::Widg ..

修饰器模式在java中很普遍(I/O操作的类)，下面是我在C++中的实现
#ifndef BASECLASS_H
#define BASECLASS_H
#include <iostream>
using namespace std;

class baseClass
{
public:
baseClass();
virtual ~baseClass()=0;
virtual void function()=0;


};

#endif // BASECLASS_H

#include "baseclass.h"

baseClass::baseClass()
{
}
baseClass::~baseClass()
{
cout<<"baseClass";
}

#ifndef SUBCLASS_1_H
#define SUBCLASS_1_H
#include "baseclass.h"
#include <iostream>
u ..

对于资源管理和特殊的对象管理，这个模式很有效
#ifndef TEST_H
#define TEST_H
#include <iostream>
using namespace std;
class Test
{
public:
static Test* getTestClass();
~Test(){cout<<"~~";}
void setI(int a) {i = a;}
int getI() const {return i;}
private:
Test();

int i;
};

#endif // TEST_H


#include "test.h"

Test::Test()
{
}
Test* Test::getTestClass()
{
static Test t;
return &t;
}

这几天把数据结构重新拿出了看，有个想法，给自己写个小的STL，这是第一个容器，向量
#ifndef MYVECTOR_H
#define MYVECTOR_H
#include <iostream>
using namespace std;
template<typename T>
class myVector
{
public:
myVector(int capacity = DEFINE_SIZE);
~myVector();
myVector(const myVector<T>& co);
myVector<T>& operator=(const myVector<T>&co);
int size() const {return _size;}
int capacity() const {return _capacity;}
T* elems() const{return p_elems;}
bool ..