C++ Decorator Pattern implementation with Arrays - c++

Question

I have implemented Decorator pattern in C++ as follows:
#include <iostream>
#include <string>
#include <deque>
using namespace std;
// Abstract Component
template <class T>
class IArray
{
public:
virtual void insert(const T&) = 0;
virtual ~IArray(){}
};
// Concrete Component
template <class T>
class Array : public IArray<T>
{
public:
virtual void insert(const T& elem)
{
m_array.push_back(elem);
}
private:
deque<T> m_array;
};
// Decorator 1
template <class T>
class PositiveArray : public IArray<T>
{
public:
PositiveArray(IArray<T>* component):m_component(component)
{
}
virtual void insert(const T& elem)
{
if (elem > 0)
{
m_component->insert(elem);
}
else
{
cerr << "You can't insert non-positive number." <<endl;
}
}
private:
IArray<T>* m_component;
};
// Decorator 2
template <class T>
class PrintArray : public IArray<T>
{
public:
PrintArray(IArray<T>* component):m_component(component)
{
}
virtual void insert(const T& elem)
{
m_component->insert(elem);
cout << "Element " << elem << " was inserted into the array." <<endl;
}
private:
IArray<T>* m_component;
};
// Client
int main()
{
typedef int MyType;
PositiveArray<MyType> arr(new PrintArray<MyType>(new Array<MyType>));
arr.insert(10);
arr.insert(-10);
int i;
cin>>i;
return 0;
}
Now I want to have for all arrays printArray function. Should I write it as a pure virtual function in IArray and copy the following implementation of that function in each child of IArray?
void printArray()
{
for (int i = 0; i < m_array.size(); ++i)
{
cout << "elem " <<i << " is " << m_array[i] <<endl;
}
}
Is there any solution that can avoid of copying?

Answer 1

I would implement for_each_element in either Array, and expose the interface in IArray. It has 2 overloads that take std::function< void(T const&) > and std::function< void(T) > (second one is optional). Now PrintArray is a one line lambda function.
In C++03 you can use boost::function, and PrintArray is more annoying to write. So here it is less tempting.
As another approach, expose const_iterators to the underlying data.
As an aside, deque performance is surprisingly poor. As yet, there is nothing in your code that would make me think you could not use a std::vector. If you guaranteed memory contiguity, you could even have your const_iterators be T const* and expose the interface directly from IArray (with the implementation in Array). for_each_element becomes a two-liner in C++11, and PrintArray even without C++11 or for_each_element is 2 lines, and either implemented inline in IArray or as a free function.
Oh, and I'd make PrintArray a free function rather than a member function. for_each_element may need to be a member function, but you should be able to PrintArray without access to private data, once you expose iterators and/or for_each_element.