C：如何创建一个临时对象，包含指针常量或非常量，具体取决于上下文？

Question

我想在向量中保存一些结构Data。这些结构通过索引（而不是指针）引用其他结构，以节省内存并使序列化更容易。为了遵循这些索引，我创建了一个类DataView，它为它提供了一个舒适的界面。它看起来像这样：

#include <iostream>
#include <vector>

struct Data
{
    int id_next;
    int id_prev;
    int value;
};

class Foo;

class DataView
{
    Foo * foo;
    int index;
public:
    DataView( Foo * foo_, int index_ )
        : foo( foo_ ), index( index_ )
    {
    }
    DataView next() const;
    DataView prev() const;
    int value() const;
    int & value();
    int id() const
    {
        return index;
    }
};

class Foo
{
    std::vector<Data> data;
public:
    friend class DataView;

    DataView dataview( int index )
    {
        return DataView( this, index );
    }

    Foo()
    {
        data.resize( 5 );
        for ( int i = 0; i < (int)data.size(); i++ )
        {
            data[i].id_next = (i + 1) % data.size();
            data[i].id_prev = (i + 4) % data.size();
            data[i].value = i * i;
        }
    }

    void write_cycle( int start_index ) // const
    {
        DataView seek = dataview( start_index );
        do
        {
            std::cout << "index " << seek.id() << " value " << seek.value() << std::endl;
            seek = seek.next();
        } while ( seek.id() != start_index );
    }
};

DataView DataView::next() const
{
    return DataView( foo, foo->data[index].id_next );
}
DataView DataView::prev() const
{
    return DataView( foo, foo->data[index].id_prev );
}
int DataView::value() const
{
    return foo->data[index].value;
}
int & DataView::value()
{
    return foo->data[index].value;
}

int main()
{
    Foo foo;
    foo.write_cycle( 3 );
    foo.dataview( 2 ).value() = 11;
    foo.write_cycle( 3 );
    return 0;
}

如果必须区分dataview方法的常量和非常量变体，就会出现问题。事实上，write\u cycle应该是const，因为它不会改变任何东西。然而，如果取消注释const限定符，则会出现编译器错误。

错误：将“const Foo”传递为“this”参数会丢弃限定符[-fpermissive]

如何编写包含常量或非常量指针的数据视图，这取决于它的构造函数是用常量还是非常量指针调用的？

Answer 1

向用户添加Sahu关于在数据视图中将Foo保留为const的回答，因为它将作为只读类，不应修改Foo；您可以将此函数添加到Foo的类中以更新其值：

void Foo::updateValue( int index, const int& value ) {
    if ( index < 0 || index >= data.size() ) {
        return;
    }

    data[index].value = value;
}

然后在主管道内。cpp文件如下所示：

Foo foo;
std::cout << "writing cycle of 3" << std::endl;
foo.write_cycle( 3 );
std::cout << "updating index 2 with value of 11" << std::endl;
foo.updateValue( 2, 11 );
std::cout << "writing cycle of 3" << std::endl;
foo.write_cycle( 3 );

Answer 2

如果一个方法是const，那么它所做的或提供的任何操作都不允许更改实例。这包括该方法调用的任何函数或其他方法，以及对该方法返回的任何成员的引用必须是const，以便将来不能使用它们修改对象。

因此，如果写入周期是常量，那么数据视图必须是常量，并且数据视图必须有一个接受常量的构造函数。这意味着要接受常量foo的赋值，foo也必须是常量。如果DataView的客户端希望操作存储的Foo，这可能会出现问题。

最终结果是，如果没有大量的额外工作，write\u cycle不可能是常量。

Answer 3

你说：

这些结构通过索引（而不是指针）引用其他结构，以节省内存并简化序列化。为了遵循这些索引，我创建了一个类DataView，它为它提供了一个舒适的界面。

这向我表明，您不需要支持：

foo.dataview( 2 ).value() = 11;

使用数据视图仅读取数据。如果您同意这一点，您可以更改数据视图来存储一个Foo const*。然后，您可以去掉非const版本的DataView：：value（）。

class DataView
{
    Foo const* foo;
    int index;
public:
    DataView( Foo const* foo_, int index_ )
        : foo( foo_ ), index( index_ )
    {
    }
    DataView next() const;
    DataView prev() const;
    int value() const;

    // Don't need this.
    // int & value();

    int id() const
    {
        return index;
    }
};