c++ - 在以下 C++ 语句中放置 const 的好地方是什么

Question

考虑以下类成员:

std::vector<sim_mob::Lane *>  IncomingLanes_;

上面的容器应该存放一些if my里的对象的指针。我不希望使用此变量作为参数的子程序能够修改 Lane 对象。同时，我不知道将不会阻止我填充容器的“const”关键字放在哪里。

你能帮我解决这个问题吗？

谢谢你和问候瓦赫德

编辑:根据我到目前为止得到的答案(非常感谢他们所有人)假设这个样本:

#include <vector>
#include<iostream>
using namespace std;

class Lane
{
private:
    int a;
public:
    Lane(int h):a(h){}
    void setA(int a_)
    {
        a=a_;
    }
    void printLane()
    {
        std::cout << a << std::endl;
    }
};

class B
{

public:
    vector< Lane const  *> IncomingLanes;
    void addLane(Lane  *l)
    {
        IncomingLanes.push_back(l);
    }

};

int main()
{
    Lane l1(1);
    Lane l2(2);
    B b;
    b.addLane(&l1);
    b.addLane(&l2);
    b.IncomingLanes.at(1)->printLane();
    b.IncomingLanes.at(1)->setA(12);
    return 1;
}

我的意思是:

b.IncomingLanes.at(1)->printLane()

应该可以毫无问题地处理 IncomingLanes 并且

b.IncomingLanes.at(1)->setA(12)

不应该被允许。(在上面的例子中，上面提到的两种方法都不起作用!)

除了解决问题之外，我还希望获得良好的编程实践。因此，如果您认为上述问题有解决方案但方式不佳，请告诉我们。塔克斯阿吉安

Answer 1

先绕个弯路:在容器中使用智能指针，如 shared_ptr 而不是原始指针。这将使您以后的生活轻松很多。

通常，您正在寻找的是 design-const，即不修改其参数的函数。您可以通过 const-reference 传递参数来实现这一点。此外，如果它是一个成员函数，则使函数const(即this在此函数的范围内变为const，因此您不能使用this 写给成员)。

如果不了解你的类，就很难建议你使用 const-reference 的容器来访问车道。这将使插入 lane 对象变得困难 - 一次性事件，只能通过 ctor(s) 中的初始化列表实现。

一些必读的内容:

• 整个FAQ 18
• 萨特 const-correctness

编辑:代码示例:

#include <vector>
#include <iostream>
//using namespace std; I'd rather type the 5 characters

// This is almost redundant under the current circumstance
#include <vector>
#include <iostream>
#include <memory>
//using namespace std; I'd rather type the 5 characters

// This is almost redundant under the current circumstance
class Lane
{
private:
    int a;
public:
    Lane(int h):a(h){}
    void setA(int a_) // do you need this?
    {
        a=a_;
    }
    void printLane() const // design-const
    {
        std::cout << a << std::endl;
    }
};

class B
{    
    // be consistent with namespace qualification
    std::vector< Lane const * > IncomingLanes; // don't expose impl. details
 public:
    void addLane(Lane const& l) // who's responsible for freeing `l'?
    {
        IncomingLanes.push_back(&l); // would change
    }
    void printLane(size_t index) const
    {
#ifdef _DEBUG 
        IncomingLanes.at( index )->printLane();
#else
        IncomingLanes[ index ]->printLane();
#endif
    }        
};

int main()
{
    Lane l1(1);
    Lane l2(2);
    B b;
    b.addLane(l1);
    b.addLane(l2);
    //b.IncomingLanes.at(1)->printLane(); // this is bad
    //b.IncomingLanes.at(1)->setA(12); // this is bad
    b.printLane(1);

    return 1;
}

此外，正如 Matthieu M. 建议的那样:

shared ownership is more complicated because it becomes difficult to tell who really owns the object and when it will be released (and that's on top of the performance overhead). So unique_ptr should be the default choice, and shared_ptr a last resort.

请注意，unique_ptr 可能需要您使用 std::move 移动它们。我正在更新示例以使用 pointer to const Lane(一个更简单的入门界面)。