Question

我被告知要将头文件写入包含此内容的main.cpp：

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.

类数组是智能指针的容器。所以我实现了counted_ptr，BaseClass和array（我使用std::vector作为容器）类，但是当我调用“print_tab_el(tab)”函数时，我得到了感叹号！

似乎所有向量的项目都是智能指针包含“！”作为名字。我从来没有把“！”那里。

这是我的标题。

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 some more.

增加：

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

counted_ptr的每个实例都有自己的reference实例。 reference的每个实例都有自己的nr_of_references实例。虽然每个counter_ptr都能正确管理reference，但问题是只有指数为1的counted_ptr会在指针超出范围时销毁指针，即使它被复制到不同的counted_ptr实例。

您的counted_ptr需要重新设计，以便同一对象的所有counted_ptr也操纵相同的reference。

输出cout是感叹号。 C ++

1 个答案: