वेक्टर इटेटरेटर dereferencable

Question

मेरे पास आकार का एक सार आधार वर्ग है जिसे सर्कल और आयत दोनों व्युत्पन्न होते हैं, लेकिन जब मैं वीएस 2005 में निम्न कोड निष्पादित करता हूं तो मुझे त्रुटि मिलती है डीबग दावा विफल हो जाता है। उसी समय मैंने किसी भी वर्ग

अभिव्यक्ति: वेक्टर इटरेटर को अस्वीकार्य नहीं किया गया है, इसके लिए कारण क्या है।

vector<Shape*> s1; 
    s1.push_back(new Circle(point(1,2),3)); 
    s1.push_back(new Circle(point(4,3),5)); 
    s1.push_back(new Rectangle(point(1,1),4,5)); 

    vector<Shape*> s2(s1); 
    reverse(s1.begin(),s1.end()); 

    (*find(s1.begin(),s1.end(),new Circle(point(1,2),3)))->move(point(10,20)); 

Answer 1

सरल:

• खोज के बाद से विफल रहता है अपने नव निर्मित सर्किल *
• एक असफल खोज अंत इटरेटर जो deferencable के रूप में पकड़ा नहीं है देता है आकार की तुलना के साथ वेक्टर में नहीं पाया जा सकता एक डीबग निश्चय के

की तरह आप चाहते हैं यह काम करने के लिए के लिए, आप आकार की तुलना करने की क्या ज़रूरत है, आकार नहीं *

+०१२३५१६४१०

जैसा कि अन्य उत्तरों में बताया गया है, boost::ptr_vector यह हासिल करने का एक आसान तरीका है।

Answer 2

जैसा @ दाऊद पियरे पता चलता है: लगता है मूल्य आधारित: यह एक सूचक (जैसे 0x0F234420) है कि करने के लिए new Circle(point(1,2),3) आपने अभी बनाया सूचक के बराबर होती है के लिए iterators की रेंज में लग रहा है। चूंकि यह एक नई वस्तु है, यह वहां नहीं होगी।

आप find_if का उपयोग कर ऑपरेटर के साथ इसका उपयोग कर सकते हैं जो पॉइंटर द्वारा संदर्भित वस्तुओं की तुलना करता है।

हालांकि, मानदंड आकार के प्रकारों के बीच अंतर करने में सक्षम होना चाहिए।

class Shape { 
public: 
    //amongst other functions 
    virtual bool equal(const Shape*) const = 0; 
}; 

class Circle : public Shape { 
public: 
    bool equal(const Shape* pOther) const { 
     const Circle* pOtherCircle = dynamic_cast<const Circle*>(pOther); 
     if(pOtherCircle == NULL) return false; 
     // compare circle members 
    } 
}; 

class Rectangle : public Shape { 
public: 
    bool equal(const Shape* pOther) const { 
     const Rectangle* pOtherR = dynamic_cast<const Rectangle*>(pOther); 
     if(pOtherR == NULL) return false; 
     // compare rectangle members 
    } 
}; 



Shape* pFindThis = new Circle(point(1,2),3); 
vector<Shape*>::const_iterator itFound = find_if(s1.begin(),s1.end(), 
    bind1st(mem_fun(&Shape::equal), pFindThis))); 
delete pFindThis; //leak resolved by Mark Ransom - tx! 

if(itFound != s1.end()) { 
    (*itFound)->move(point(10,20)); 
} 

Answer 3

यह boost :: ptr_vector का उपयोग करने का एक अच्छा कारण है।

यह न केवल इस तथ्य को संभालता है कि आपकी वस्तुओं को नष्ट करने की आवश्यकता है।
xtofl @: आप वर्चुअल विनाशक भूल गए हैं।

लेकिन यह सदस्यों को पॉइंटर्स के बजाय संदर्भ लौटने से वस्तुओं की तरह दिखता है। यह आपको अपने 'बराबर' फ़ंक्शन में पॉइंटर्स के साथ खेलने के बजाए मानक एल्गोरिदम का अधिक स्वाभाविक रूप से उपयोग करने की अनुमति देता है (जो बहुत सी सी ++ जैसा है)।

#include <boost/ptr_container/ptr_vector.hpp> 
#include <iostream> 

class Shape 
{ 
    public: 
     ~Shape() {} 
     bool operator==(Shape const& rhs) const 
     { 
      if (typeid(*this) != typeid(rhs)) 
      { 
       return false; 
      } 

      return this->isEqual(rhs); 
     } 
    private: 
     virtual bool isEqual(Shape const& rhs) const = 0; 
}; 

class Circle: public Shape 
{ 
    public: 
     Circle(int r) 
      :radius(r) 
     {} 
    private: 
     virtual bool isEqual(Shape const& r) const 
     { 
      Circle const& rhs = dynamic_cast<Circle const&>(r); 
      return radius == rhs.radius; 
     } 
     int radius; 
}; 
class Rectangle: public Shape 
{ 
    public: 
     Rectangle(int h,int w) 
      :height(h) 
      ,width(w) 
     {} 
    private: 
     virtual bool isEqual(Shape const& r) const 
     { 
      Rectangle const& rhs = dynamic_cast<Rectangle const&>(r); 
      return (height == rhs.height) && (width == rhs.width); 
     } 
     int height; 
     int width; 
}; 


int main() 
{ 

    boost::ptr_vector<Shape> data; 

    data.push_back(new Circle(5)); 
    data.push_back(new Circle(6)); 
    data.push_back(new Rectangle(7,4)); 

    boost::ptr_vector<Shape>::iterator f; 
    f = find(data.begin(),data.end(),Circle(6)); 

    std::cout << "Find(" << (f - data.begin()) << ")" << std::endl; 


}