#ifndef _SINGLETON_H_
#define _SINGLETON_H_
#include <iostream>
using namespace std;
class Singleton
{
public:
static Singleton* Instance();
protected:
Singleton();
private:
static Singleton* _instance;
};
#endif //~_SINGLETON_H_
#include "Singleton.h"
#include <iostream>
using namespace std;
Singleton* Singleton::_instance = 0;
Singleton::Singleton()
{
cout<<"Singleton...."<<endl;
}
Singleton* Singleton::Instance()
{
if (_instance == 0)
{
_instance = new Singleton();
}
return _instance;
}
//main.cpp
#include "Singleton.h"
#include <iostream>
using namespace std;
int main(int argc,char* argv[])
{
Singleton* sgn = Singleton::Instance();
return 0;
}
Singleton 不可以被实例化，因此
我们将其构造函数声明为 protected 或者直接声明为 private。
#pragma once
#include "GeometricFigure.h"
#include "Circular.h"
class Circular :public GeometricFigure
{
public:
Circular();
~Circular();
Circular(const double & t_radius);
void CalculatedArea();
void DisplayArea();
protected:
private:
double m_radius;
};
#include <StdAfx.h>
#include "Circular.h"
#define PI 3.1415926
Circular::Circular() :m_radius(0)
{
}
Circular::Circular(const double & t_radius)
{
m_radius = t_radius;
CalculatedArea();
}
Circular::~Circular()
{
}
void Circular::CalculatedArea()
{
m_area = m_radius * m_radius * PI;
}
void Circular::DisplayArea()
{
std::cout << "圆形面积:" << m_area << std::endl;
}
#pragma once
#include "GeometricFigure.h"
class Rectangle :public GeometricFigure
{
public:
Rectangle();
~Rectangle();
Rectangle(const double & t_width, const double & t_long);
void CalculatedArea();
void DisplayArea();
protected:
private:
double m_width;
double m_long;
};
#include <StdAfx.h>
#include "Rectangle.h"
Rectangle::Rectangle() :m_width(0.f), m_long(0.f)
{
}
Rectangle::Rectangle(const double &t_width, const double& t_long)
{
m_width = t_width;
m_long = t_long;
CalculatedArea();
}
Rectangle::~Rectangle()
{
}
void Rectangle::CalculatedArea()
{
m_area = m_width * m_width;
}
void Rectangle::DisplayArea()
{
std::cout << "矩形面积:"<< m_area << std::endl;
}
#pragma once
#include "GeometricFigure.h"
class Factory
{
public:
Factory();
~Factory();
virtual GeometricFigure *create() = 0;
protected:
private:
};
#include <StdAfx.h>
#include "Factory.h"
Factory::Factory()
{
}
Factory::~Factory()
{
}
#pragma once
#include "Factory.h"
#include "Rectangle.h"
class Factory_A :public Factory
{
public:
Factory_A();
~Factory_A();
GeometricFigure * create();
protected:
private:
};
#include <StdAfx.h>
#include "Factory_A.h"
Factory_A::Factory_A()
{
}
Factory_A::~Factory_A()
{
}
GeometricFigure * Factory_A::create()
{
return new Rectangle(4.0, 4.0);
}
#pragma once
#include "Factory.h"
#include "Circular.h"
class Factory_B :public Factory
{
public:
Factory_B();
~Factory_B();
GeometricFigure * create();
protected:
private:
};
#include <StdAfx.h>
#include "Factory_B.h"
Factory_B::Factory_B()
{
}
Factory_B::~Factory_B()
{
}
GeometricFigure * Factory_B::create()
{
return new Circular(4);
}
#pragma once
#include <iostream>
class GeometricFigure
{
public:
GeometricFigure();
~GeometricFigure();
virtual void CalculatedArea() = 0;
virtual void DisplayArea() = 0;
protected:
double m_area;
public:
};
#include <StdAfx.h>
#include "GeometricFigure.h"
GeometricFigure::GeometricFigure()
{
}
GeometricFigure::~GeometricFigure()
{
}
// polymorphic.cpp : 定义控制台应用程序的入口点。
//
#include "stdafx.h"
#include "Factory_A.h"
#include "Factory_B.h"
int _tmain(int argc, _TCHAR* argv[])
{
Factory_A * a = new Factory_A;
Factory_B * b = new Factory_B;
GeometricFigure * p1 = a->create();
GeometricFigure * p2 = b->create();
p1->DisplayArea();
p2->DisplayArea();
delete a;
delete b;
return 0;
}