Adapter Pattern
The adapter pattern is able to convert an interface into another, and let incompatible interfaces work together. It is also a structural pattern.
There are two popular interface in multimedia devices, HDMI and VGA. Suppose we have a VGA class, and a display device TV1 which uses the interface.
class VGA {
public:
virtual void play() = 0;
};
class TV1 : public VGA {
public:
void play() {
cout << "TV1: VGA" << endl;
}
};
What’s more, we have a computer which supports VGA interface:
class Computer {
public:
void playVideo(VGA *pVGA) {
pVGA->play();
}
};
Since the interfaces of the computer and the screen are consistent, we can directly connect them together by passing a VGA pointer into the playVideo() method.
int main() {
Computer computer;
computer.playVideo(new TV1()); // TV1: VGA
return 0;
}
Now suppose we have another monitor which supports HDMI interface:
class HDMI {
public:
virtual void play() = 0;
};
class TV2 : public HDMI {
public:
void play() {
cout << "TV2: HDMI" << endl;
}
};
Since our computer only takes a VGA pointer, we can not use this monitor directly. There are two ways to do so. We can simply change a computer which supports HDMI, which is equivalent to code refactoring. This method is once and for all, but would be a painful thing if there are a large amount of code. Or we can use an adapter which convert VGA into HDMI.
Here we add an Adapter class which inherits from VGA. The class keeps a HDMI pointer as its member variable, and calls the play() method of HDMI from its own play() method.
class Adapter : public VGA {
public:
Adapter(HDMI *p) : pHDMI(p) {}
void play() {
pHDMI->play();
}
private:
HDMI *pHDMI;
};
Then we can use our adapter to connect the computer to TV2. The playVideo() method takes the VGA adapter, which is constructed by the HDMI object.
int main() {
Computer computer;
computer.playVideo(new Adapter(new TV2())); // TV2: HDMI
return 0;
}
