容器(vector)和指针(ptr)的区别

Posted 2023-04-03

小弟在阅读c++ primer

其中建议尽量用容器(vector),说指针(ptr)和数组等与容器(vector)和迭代器原理差不多,但是建议用后者.
指出前者容易出错,只是由于继承了c,而且现在很多地方都在大面积使用,故而还是要重点学的.而容器(vector)是标准库里的类,这本书上建议后者比较好.

请问有经验的朋友,是这样吗?容器(vector)和指针(ptr)还有些什么区别呢?实际应用中它们的原理真是类似的么?到底哪种用的比较多呢?

既然你选择使用C++ 就应该熟练使用它的STL。
STL是C++非常宝贵的一部分，提供了许多对C的优化。
就像你这里说的vector和指针。
vector就安全得多，并且提供了很多方便的操作；
使用vector不仅你会出错更少，并且很多烦琐的代码你都不用编写，它都是vector自带的。 参考技术A 指针、数组、容器的区别
指针存的是地址。数组存的是一片数据区的首地址。容器是一个C++模板类。
指针在WIN32API中常作参数，这点和容器数组等是有很大差别的。
容器可以看做是对数组或者链表等数据结构的一种封装。

建议是如果开发win32应用程序，要会熟练使用指针；否则stl始终是非常好的选择。这个问题是不是应该发在C++区呢？？ 参考技术B 区别不大,但是用什么,要看需要

智能指针的迭代和容器

【中文标题】智能指针的迭代和容器

【英文标题】：Iterating & containers of smart pointers

【发布时间】：2010-02-12 23:45:16

【问题描述】：

我有一个指向可变对象的智能指针容器。我必须编写两个 for_each 循环，一个用于将对象作为只读数据访问，另一个用于可变数据。编译器告诉我std::vector< boost::shared_ptr<Object> > 与std::vector< boost::shared_ptr<const Object> > 不同，请注意const。

这是我的示例代码：

#include <vector>
#include "boost/shared_ptr.hpp"
#include <iterator>

class Field_Interface
 ; ;
typedef boost::shared_ptr<Field_Interface> Ptr_Field_Interface;
typedef boost::shared_ptr<const Field_Interface> Ptr_Const_Field_Interface;

struct Field_Iterator
  : std::input_iterator<std::forward_iterator_tag, Ptr_Field_Interface>

  // forward iterator methods & operators...
;

struct Const_Field_Iterator
  : std::input_iterator<std::forward_iterator_tag, Ptr_Const_Field_Interface>

  // forward iterator methods & operators...
;

struct Field_Functor

  virtual void operator()(const Ptr_Field_Interface&) = 0;
  virtual void operator()(const Ptr_Const_Field_Interface&) = 0;
;

class Record;
typedef boost::shared_ptr<Record> Ptr_Record;
typedef boost::shared_ptr<const Record> Ptr_Const_Record;

class Record_Base

  protected:
    virtual Field_Iterator beginning_field(void) = 0;
    virtual Field_Iterator ending_field(void) = 0;
    virtual Const_Field_Iterator const_beginning_field(void) = 0;
    virtual Const_Field_Iterator const_ending_field(void) = 0;

    void for_each(Field_Functor * p_functor)
    
       Field_Iterator iter_begin(beginning_field());
       Field_Iterator iter_end(ending_field());
       for (; iter_begin != iter_end; ++ iter_begin)
       
         (*p_functor)(*iter_begin);
       
     
;

class Record_Derived

public:
   typedef std::vector<Ptr_Field_Interface> Field_Container;
   typedef std::vector<Ptr_Record>          Record_Container;
private:
   Field_Container m_fields;
   Record_Container m_subrecords;
;

鉴于以上所有细节，如何在Record_Derived 中实现Record_Base 的纯抽象方法？

我试过了：

返回m_fields.begin()， 返回转换错误（不能 转换std::vector<...> to Field_Iterator) 返回&m_fields[0]，即 危险的，因为它假设了一些东西 关于std::vector的内部结构。

顺便说一句，我没有使用 std::for_each，因为我必须遍历字段容器和子记录容器。

【问题讨论】：

我很好奇，你用什么编译器来编译样本？ VC8 和 GCC3/4 不起作用。

@gf：我认为他可能正在使用 STLPort，它仍然具有 std::forward_iterator 模板，用于向后兼容标准的早期草案。

@gf, @Emile：我的错，标识符应该是std::forward_iterator_tag。我正在使用 MS Visual Studio 2008。给出的最喜欢的示例无法编译，因为它是用于显示概念的精简版本。

【参考方案1】：

您所做的与Composite 和Visitor 模式相似。这两种模式很好地融合在一起，所以您似乎走在了正确的轨道上。

要实现复合模式，请分配以下角色（请参阅复合模式 UML 图）：

叶 -> Field 复合 -> Record 组件->Field和Record的抽象基类（想不出好名字）

在复合类型上调用的组件操作会以递归方式传递给所有子类型（叶子和其他嵌套的复合类型）。

要实现访问者模式，请在仿函数类中为每个组件子类型（字段和记录）重载 operator()。

我建议您阅读“四人帮”的 Design Patterns 书籍，它更好地解释了这些概念，并且比我可能做的更详细。

这里有一些示例代码可以激发您的兴趣：

#include <iostream>
#include <vector>
#include "boost/shared_ptr.hpp"
#include "boost/foreach.hpp"

class Field;
class Record;

struct Visitor

    virtual void operator()(Field& field) = 0;
    virtual void operator()(Record& field) = 0;
;

class Component

public:
    virtual bool isLeaf() const return true;
    virtual void accept(Visitor& visitor) = 0;
;
typedef boost::shared_ptr<Component> ComponentPtr;

class Field : public Component

public:
    explicit Field(int value) : value_(value) 
    void accept(Visitor& visitor) visitor(*this);
    int value() const return value_;

private:
    int value_;
;

class Record : public Component

public:
    typedef std::vector<ComponentPtr> Children;
    Record(int id) : id_(id) 
    int id() const return id_;
    Children& children() return children_;
    const Children& children() const return children_;
    bool isLeaf() const return false;
    void accept(Visitor& visitor)
    
        visitor(*this);
        BOOST_FOREACH(ComponentPtr& child, children_)
        
            child->accept(visitor);
        
    

private:
    int id_;
    Children children_;
;
typedef boost::shared_ptr<Record> RecordPtr;

struct OStreamVisitor : public Visitor

    OStreamVisitor(std::ostream& out) : out_(out) 
    void operator()(Field& field) out_ << "field(" << field.value() << ") ";
    void operator()(Record& rec) out_ << "rec(" << rec.id() << ") ";
    std::ostream& out_;
;

int main()

    RecordPtr rec(new Record(2));
        rec->children().push_back(ComponentPtr(new Field(201)));
        rec->children().push_back(ComponentPtr(new Field(202)));
    RecordPtr root(new Record(1));
        root->children().push_back(ComponentPtr(new Field(101)));
        root->children().push_back(rec);

    OStreamVisitor visitor(std::cout);
    root->accept(visitor);

在 Record 中，您可能希望提供用于操作/访问子级的方法，而不是返回对底层子级向量的引用。

【讨论】：

@Emile：谢谢，我对Visitor很熟悉，我会用复合模式来刷新我的记忆。我突然想到一个想法：将Record_Base 简化为容器，并转换为标准容器惯用语，以便std::for_each 可以在Record_Base 容器上工作。

【参考方案2】：

我建议不要在使用通用容器类型时编写自己的迭代器。当您编写自己的容器时，编写自己的迭代器是有意义的。但是，当您计划编写自定义迭代器时，请查看 Boost.Iterator 包。

【参考方案3】：

如果你想对用户隐藏std::vector 及其迭代器，那么你需要提供多态迭代器来配合你的多态RecordBase 容器。从 Adob​​e ASL 库中查看 any_iterator。 Theselinks 也可能有帮助。

但是，您应该考虑在设计中使用 Composite 和 Visitor 模式，而不是费尽心思。请参阅我的其他答案。