0

我被告知将头文件写入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_ptrBaseClassarray(我用作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"

参考资料.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;
    }
/****************************************************************************/

参考资料.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;

};
4

1 回答 1

1

每个实例counted_ptr都有自己的实例reference。每个实例reference都有自己的实例nr_of_references。尽管每个都counter_ptr管理reference得当,但问题是counted_ptr只有计数为 1 的指针会在超出范围时破坏指针,即使在它被复制到不同的counted_ptr实例之后也是如此。

counted_ptr需要重新设计,以便counted_ptr同一对象的所有 s 也操作相同reference

于 2013-10-02T21:59:54.320 回答