Design Pattern-abstract factory pattern (abstactfactory) Creation Pattern

The typical structure of the abstractfactory mode is as follows:

 

 

 

 

The abstractfactory mode provides interfaces for creating a group of (multi-class) related or dependent objects, the factory mode, as I analyzed in the relevant documents, provides interfaces for creating a class of objects or delays the creation of objects into subclass. As you can see, the abstractfactory mode is usually implemented in the factory mode (concretefactory1 ).

 

 

 

In the abstractfactory mode, the key is to encapsulate the creation of this group of objects into a concretefactory, maintaining such a creation class is much easier than maintaining the creation process of N-related objects.

 

 

------------------------- Product. h ---------------------------------
# Pragma once

 

Class abstractproduproducta
{
Public:
Virtual ~ Abstractproducta () = 0;
Protected:
Abstractproducta ();
};

 

Class abstractproductb
{
Public:
Virtual ~ Abstractproductb () = 0;
Protected:
Abstractproductb ();
};

 

Class producta0: Public abstractproducta
{
Public:
Producta0 ();
~ Producta0 ();
};

 

Class producta1: Public abstractproducta
{
Public:
Producta1 ();
~ Producta1 ();
};

Class productb0: Public abstractproductb
{
Public:
Productb0 ();
~ Productb0 ();
};

 

Class productb1: Public abstractproductb
{
Public:
Productb1 ();
~ Productb1 ();
};

------------------------- Product. cpp -------------------------------
# Include "stdafx. H"
# Include "product. H"
# Include <iostream>
Using namespace STD;

 

Abstractproducta: abstractproducta (){}

Abstractproducta ::~ Abstractproducta (){}

Abstractproductb: abstractproductb (){}

Abstractproductb ::~ Abstractproductb (){}

 

Producta0: producta0 ()
{
Cout <"producta0 constructor" <Endl;
}

Producta0 ::~ Producta0 (){}

 

Productb0: productb0 ()
{
Cout <"productb0 constructor" <Endl;
}

Productb0 ::~ Productb0 (){}

 

Producta1: producta1 ()
{
Cout <"producta1 constructor" <Endl;
}

Producta1 ::~ Producta1 (){}

 

Productb1: productb1 ()
{
Cout <"productb1 constructor" <Endl;
}

Productb1 ::~ Productb1 (){}
------------------------- Factory. h ---------------------------------
# Pragma once

Class abstractproducta;
Class abstractproductb;

Class abstructfactory
{
Public:
Virtual ~ Abstructfactory () = 0;
Abstructfactory ();

Virtual abstractproducta * createproducta () = 0;
Virtual abstractproductb * createproductb () = 0;
};

Class

Concretefactory0: Public abstructfactory
{
Public:
Concretefactory0 ();
~ Concretefactory0 ();

Abstractproducta * createproducta ();
Abstractproductb * createproductb ();
};

 

Class concretefactory1: Public abstructfactory
{
Public:
Concretefactory1 ();
~ Concretefactory1 ();

Abstractproducta * createproducta ();
Abstractproductb * createproductb ();
};

------------------------- Factory. cpp -------------------------------
# Include "stdafx. H"
# Include "product. H"
# Include "factory. H"

Abstructfactory: abstructfactory (){}

Abstructfactory ::~ Abstructfactory (){}

Concretefactory0: concretefactory0 (){}
Concretefactory0 ::~ Concretefactory0 (){}

 

Abstractproducta * concretefactory0: createproducta ()
{
Return new producta0;
}

 

Abstractproductb * concretefactory0: createproductb ()
{
Return new productb0;
}

Concretefactory1: concretefactory1 (){}
Concretefactory1 ::~ Concretefactory1 (){}

 

Abstractproducta * concretefactory1: createproducta ()
{
Return new producta1;
}

 

Abstractproductb * concretefactory1: createproductb ()
{
Return new productb1;
}
------------------------- Main. cpp ----------------------------------
# Include "stdafx. H"
# Include "product. H"
# Include "factory. H"
# Include <iostream>

Using namespace STD;

Int main ()
{
Concretefactory0 * fac0 = new concretefactory0;
Concretefactory1 * fac1 = new concretefactory1;

Abstractproducta * proa0 = fac0-> createproducta ();
Abstractproductb * prob0 = fac0-> createproductb ();
Abstractproducta * proa1 = fac1-> createproducta ();
Abstractproductb * prob1 = fac1-> createproductb ();

Delete prob1;
Delete proa1;
Delete prob0;
Delete proa0;
Delete fac1;
Delete fac0;

Return 0;
}
-------------------------------------------------------------------