Output cout is exclamation mark. C++ - c++

Question

I've been told to write header file to the main.cpp which contains this:
OOP::array tab;
for(int i = 0; i < rand()%10 + 1; ++i)
{
tab.push_back(new BaseClass("BaseClass 1"));
tab.push_back(new BaseClass("BaseClass 2"));
tab.push_back(new BaseClass("BaseClass 3"));
}
OOP::print_tab_el(tab); //prints tab using operator<< for its elements.
Class array is a container for smart pointers.
So I implemented counted_ptr, BaseClass and array (I used std::vector as a container) classes but when I invoke "print_tab_el(tab)" function, I get exclamation mark!
Seems like all of vector's items which are smart pointers contain "!" as name. I never put an "!" there.
Here's my header.
namespace OOP {
class BaseClass
{
public:
std::string name;
BaseClass(std::string arg) {name=arg;}
friend std::ostream & operator<<(std::ostream &os, const BaseClass& ref)
{
os<<ref.name<<"\n"; //gives ! ???
return os;
}
};
class array
{
public:
std::vector <counted_ptr<OOP::BaseClass> > myvec;
void push_back( OOP::BaseClass *arg)
{
counted_ptr< OOP::BaseClass> tmp(arg);
myvec.push_back(tmp);
}
};
void print_tab_el(array arr)
{
std::vector <counted_ptr<OOP::BaseClass> >::iterator it;
for (it=arr.myvec.begin();it!=arr.myvec.end();++it){
std::cout<<**it;
}
}
};
And this is program output:
!
!
!
!
!
!
!
!
and some more.
ADDED:
counted_ptr.cpp
#ifndef COUNTED_PTR_CPP
#define COUNTED_PTR_CPP
#include "counted_ptr.h"
#include <iostream>
/****************************************************************************/
template <class T>
counted_ptr<T>::counted_ptr(T* pointer):ptr(pointer)
{
refs.addRef();
}
/****************************************************************************/
template <class T>
counted_ptr<T>::counted_ptr(const counted_ptr& ref):ptr(ref.ptr), refs(ref.refs+1) {}
/****************************************************************************/
template <class T>
counted_ptr<T>::~counted_ptr()
{
if (refs.takeRef()==0)
delete ptr;
}
/****************************************************************************/
template <class T>
T* counted_ptr<T>::operator->(){
return ptr;
}
/****************************************************************************/
template <class T>
T& counted_ptr<T>::operator*(){
return *ptr;
}
/****************************************************************************/
template <class T>
counted_ptr<T>& counted_ptr<T>::operator=(const counted_ptr<T>& rcpt_r){
if (this!=&rcpt_r)
{
if (refs.takeRef()==0)
delete ptr;
ptr=rcpt_r.ptr;
//refs=rcpt_r.refs+1;
refs=rcpt_r.refs;
refs.addRef();
}
return *this;
}
/****************************************************************************/
#endif
counted_ptr.h
#ifndef COUNTED_PTR_H
#define COUNTED_PTR_H
#include "reference.h"
template <class T>
class counted_ptr{
public:
counted_ptr( T* pointer);
counted_ptr(const counted_ptr& ref);
~counted_ptr();
T* operator->();
T& operator*();
counted_ptr& operator=(const counted_ptr<T>& ref);
private:
T *ptr;
reference refs;
};
class testclass{};
#endif
#include "counted_ptr.cpp"
reference.cpp
#include "reference.h"
#include <iostream>
/****************************************************************************/
reference::reference():nr_of_references(0){}
/****************************************************************************/
reference::reference(const int value):nr_of_references(value){}
reference& reference::operator=(const int& ref)
{
nr_of_references=ref;
return *this;
}
/****************************************************************************/
reference::operator int()const
{
return nr_of_references;
}
/****************************************************************************/
int reference::addRef()
{
return ++nr_of_references;
}
/****************************************************************************/
int reference::takeRef()
{
return --nr_of_references;
}
/****************************************************************************/
reference.h
class reference{
public:
reference();
reference(const int value);
//reference& operator=(const reference& ref);
reference& operator=(const int& ref);
operator int()const;
int addRef();
int takeRef();
private:
int nr_of_references;
};

Answer 1

Every instance of counted_ptr has its own instance of reference. Each instance of reference has its own instance of nr_of_references. Although each counter_ptr manages reference properly, the problem is that the counted_ptr that only had a count of 1 will destruct the pointer when it goes out of scope, even after it was copied to a different counted_ptr instance.
Your counted_ptr needs to be redesigned so that all counted_ptrs to the same object also manipulate the same reference.