#include <iostream>
#include <vector>
#include <memory>
using namespace std;
template < typename T>
struct ObjectPointers {
const std:: shared_ptr < ObjectPointers< T>> left;
const std:: shared_ptr < ObjectPointers< T>> right;
std:: vector < T> data;
// initialize left and right in constructor
ObjectPointers( std:: initializer_list < T> list) : data( list) {
}
ObjectPointers( const ObjectPointers & c) = default ;
~ObjectPointers( ) { // no need, shared ptr take care
}
ObjectPointers( std:: shared_ptr < ObjectPointers< T>> left, std:: shared_ptr < ObjectPointers< T>> right) : left( left) , right( right) { }
void show( ) const {
std:: cout << "data\n " ;
for ( auto & x: data)
std:: cout << "\t " << x<< std:: endl ;
std:: cout << "end of data\n " ;
if ( left) {
std:: cout << "Recurstive left:\n " ;
left- > show( ) ;
std:: cout << "end of recursive left\n " ;
}
else cout << "no left\n " ;
if ( right) {
std:: cout << "Recurstive right:\n " ;
right- > show( ) ;
std:: cout << "end of recursive right\n " ;
}
else cout << "no right\n " ;
}
} ;
//overload +
template < class T>
ObjectPointers< T> operator+ ( ObjectPointers< T> a, ObjectPointers< T> b) {
// I create a new object with the left and right of the current object
return ObjectPointers< T> ( std:: make_shared < ObjectPointers< T>> ( a) , std:: make_shared < ObjectPointers< T>> ( b) ) ;
}
int main( ) {
ObjectPointers< int > a = { 1 , 2 , 3 } ;
ObjectPointers< int > b = { 4 , 5 , 6 } ;
ObjectPointers< int > c = a + b;
c.show ( ) ;
return 0 ;
}
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