c/c++问题集五

#include <pthread.h>
 
int pthread_spin_destroy(pthread_spinlock_t *lock);
int pthread_spin_init(pthread_spinlock_t *lock, int pshared);
 
int pthread_spin_lock(pthread_spinlock_t *lock);
int pthread_spin_trylock(pthread_spinlock_t *lock);
int pthread_spin_unlock(pthread_spinlock_t *lock);

// 声明一个读写锁
pthread_rwlock_t rwlock;
...
// 在读之前加读锁
pthread_rwlock_rdlock(&rwlock);
 
... 共享资源的读操作
 
// 读完释放锁
pthread_rwlock_unlock(&rwlock);
 
// 在写之前加写锁
pthread_rwlock_wrlock(&rwlock); 
 
... 共享资源的写操作
 
// 写完释放锁
pthread_rwlock_unlock(&rwlock);
 
// 销毁读写锁
pthread_rwlock_destroy(&rwlock);

// version 1.3
class Singleton
{
private:
	static Singleton instance;
private:
	Singleton();
	~Singleton();
	Singleton(const Singleton&);
	Singleton& operator=(const Singleton&);
public:
	static Singleton& getInstance() {
		return instance;
	}
}

// initialize defaultly
Singleton Singleton::instance;

class Sigletion2
{
	Sigletion2()
	{
		cout << "Sigletion2()" <<endl;
	}
 
	static Sigletion2* intance2;
 
public:
 
	static Sigletion2* GetSigletion2()
	{
		if (intance2 == NULL)
		{
			intance2 = new Sigletion2();
			cout << "it is once" <<endl;
		}
		else
		{
			cout << "it is not once" <<endl;
		}
		return intance2;
 
	}
 
};
 
Sigletion2* Sigletion2:: intance2 = NULL;  //先初始化为空，等真正用上这个单例的时候再创建这个例。

class singleton
{
private:
	singleton()
	{
		pthread_mutex_init(&mutex);
	}
 
	static singleton* p;
	static pthread_mutex_t mutex;
public:
	static singleton* initance()
	{
		if (p == NULL)   //p != NULL,说明对象已经创建出来了，直接返回对象的指针，没必要在加锁解锁浪费时间。
		{
			pthread_mutex_lock(&mutex);
			if (p == NULL)
			{
				p = new singleton();
			}
			pthread_mutex_unlock(&mutex);
		}
		return p;
	}
};
 
pthread_mutex_t singleton::mutex;
singleton* singleton::p = NULL;

class Singleton{
private:
    Singleton(){printf("Singeleton init \n");};
    ~Singleton(){printf("delete Singeleton \n");};
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) =delete;
public:
    static Singleton* GetInstance(){
        static Singleton instance;  //函数内的静态局部变量，第一次访问才初始化，程序结束，自动释放。
        return &instance;
    }
};

#include <iostream> 
#include <stdlib.h> 

using namespace std;

typedef enum ProductType
{
	TypeA,
	TypeB,
	TypeC
}ProductType_t;

/* 产品抽象基类 */
class Product
{
public:
	virtual void printf() = 0;
};
class ProductA : public Product
{
public:
	void printf()
	{
		cout<<"Create productA"<<endl;
	}
};
class ProductB : public Product
{
public:
	void printf()
	{
		cout<<"Create productB"<<endl;
	}

};
class ProductC : public Product
{
public:
	void printf()
	{
		cout<<"Create productC"<<endl;
	}

};

/* 工厂类 */
class Factory
{
public:
	Product* CreateProduct(ProductType_t type);
};

Product* Factory::CreateProduct(ProductType_t type)
{
	Product *a = NULL;
	
	switch (type)
	{
		case TypeA:
			a = new ProductA();
		break;
		case TypeB:
			a = new ProductB();
		break;
		case TypeC:
			a = new ProductC();
		break;
		default:
		break;
	}
	return a;
}

int main(int argc, char **argv)
{
	Factory productCreator;
	
	Product *productA;
	Product *productB;
	Product *productC; 

	productA = productCreator.CreateProduct(TypeA);
	productB = productCreator.CreateProduct(TypeB);
	productC = productCreator.CreateProduct(TypeC);
	if(productA != NULL)
	{
		productA->printf();
		delete productA;
		productA=NULL;
	}
	if(productB != NULL)
	{
		productB->printf();
		delete productB;
		productB=NULL;
	}
	if(productC != NULL)
	{
		productC->printf();
		delete productC;
		productC=NULL;
	}
	return 0;
}

#include <iostream> 
#include <stdlib.h> 

using namespace std;


/* 产品抽象基类 */
class Product
{
public:
	virtual void printf() = 0;
};
class ProductA : public Product
{
public:
	void printf()
	{
		cout<<"Create productA"<<endl;
	}
};
class ProductB : public Product
{
public:
	void printf()
	{
		cout<<"Create productB"<<endl;
	}

};
class ProductC : public Product
{
public:
	void printf()
	{
		cout<<"Create productC"<<endl;
	}

};

/* 工厂类 */
class Factory
{
public:
	virtual Product* CreateProduct()=0;
};

class FactoryA:public Factory
{
public:
	Product *CreateProduct()
	{
		return new ProductA();
	}
};
class FactoryB:public Factory
{
public:
	Product *CreateProduct()
	{
		return new ProductB();
	}
};

class FactoryC:public Factory
{
public:
	Product *CreateProduct()
	{
		return new ProductC();
	}
};


int main(int argc, char **argv)
{
	Factory *factoryA;
	Factory *factoryB;
	Factory *factoryC;
	Product *productA;
	Product *productB;
	Product *productC; 

	factoryA = new FactoryA(); 
	if(factoryA != NULL)
	{
		productA = factoryA->CreateProduct(); 
		if (productA != NULL)
		{
			productA->printf();
			delete productA;
			productA = NULL;
		}
		delete factoryA;
		factoryA = NULL;
	}
	
	factoryB = new FactoryB(); 
	if(factoryB != NULL)
	{
		productB = factoryB->CreateProduct(); 
		if (productB != NULL)
		{
			productB->printf();
			delete productB;
			productB = NULL;
		}
		delete factoryA;
		factoryA = NULL;
	}
	
	factoryC = new FactoryC(); 
	if(factoryC != NULL)
	{
		productC = factoryC->CreateProduct(); 
		if (productC != NULL)
		{
			productC->printf();
			delete productC;
			productC = NULL;
		}
		delete factoryC;
		factoryC = NULL;
	}
	return 0;
}

#include <iostream> 
#include <stdlib.h> 

using namespace std;


/* 产品A抽象基类 */
class ProductA
{
public:
	virtual void printf() = 0;
};

/* 产品类A0 */
class ProductA0 : public ProductA
{
public:
	void printf()
	{
		cout<<"Create productA0"<<endl;
	}
};

/* 产品类A1 */
class ProductA1 : public ProductA
{
public:
	void printf()
	{
		cout<<"Create productA1"<<endl;
	}
};

/* 产品B抽象基类 */
class ProductB
{
public:
	virtual void printf() = 0;
};

/* 产品类B0 */
class ProductB0 : public ProductB
{
public:
	void printf()
	{
		cout<<"Create productB0"<<endl;
	}
};

/* 产品类B1 */
class ProductB1 : public ProductB
{
public:
	void printf()
	{
		cout<<"Create productB1"<<endl;
	}
};

/* 工厂类 */
class Factory
{
public:
	virtual ProductA* CreateProductA()=0;
	virtual ProductB* CreateProductB()=0;
};

/* 工厂类0，专门生产0类产品 */
class Factory0:public Factory
{
public:
	ProductA *CreateProductA()
	{
		return new ProductA0();
	}
	ProductB *CreateProductB()
	{
		return new ProductB0();
	}
};

/* 工厂类1，专门生产1类产品 */
class Factory1:public Factory
{
public:
	ProductA *CreateProductA()
	{
		return new ProductA1();
	}
	ProductB *CreateProductB()
	{
		return new ProductB1();
	}
};

int main(int argc, char **argv)
{
	Factory *factory0;
	Factory *factory1;
	ProductA *productA0;
	ProductA *productA1;
	ProductB *productB0; 
	ProductB *productB1;

	factory0 = new Factory0(); 
	if(factory0 != NULL)
	{
		productA0 = factory0->CreateProductA(); 
		if (productA0 != NULL)
		{
			productA0->printf();
			delete productA0;
			productA0 = NULL;
		}

		productB0 = factory0->CreateProductB(); 
		if (productB0 != NULL)
		{
			productB0->printf();
			delete productB0;
			productB0 = NULL;
		}
		delete factory0;
		factory0 = NULL;
	}
	
	factory1 = new Factory1(); 
	if(factory1 != NULL)
	{
		productA1 = factory1->CreateProductA(); 
		if (productA1 != NULL)
		{
			productA1->printf();
			delete productA1;
			productA1 = NULL;
		}

		productB1 = factory1->CreateProductB(); 
		if (productB1 != NULL)
		{
			productB1->printf();
			delete productB1;
			productB1 = NULL;
		}
		delete factory1;
		factory1 = NULL;
	}
	return 0;
}