正确使用 const c++

发布于 2024-11-06 07:47:45 字数 1094 浏览 1 评论 0原文

我有这个示例代码(如下), example1() 方法工作没有问题, example2() 类似,但我必须强制 const_char 使其编译,尽管我认为不需要 example1() 方法, example2() 将是也不需要。

我的问题是,如何修改 add() 方法以进行编译,或者如何在 example2() 中正确调用 buffer.add() 而不强制 const_cast ? add() 方法不修改 item,因此 const_cast 是不必要的。哪种形式是正确或合适的?

这是示例代码:

template <class Item>
class Buffer
{
public:
    Item *      _pItems;
    int         _nItems;
    // ... constructor / destructors etc
    void    add( const Item & item ) // or maybe Item const & item
    {
        _pItems[_nItems++] = item;
    }
};
class MyClass
{
public:
    // data
};
void    example1( const MyClass & item )
{
    Buffer<MyClass>        buffer;
    buffer.add( item );  // WORKS, no problem
}
void    example2( const MyClass & item )
{
    Buffer<MyClass *>        buffer; // NOW with pointers to MyClass
    //buffer.add( item );  // ERROR: 'Buffer<Item>::add' : cannot convert parameter 1 from 'const MyClass' to 'MyClass *const &'
    buffer.add( const_cast<MyClass *>( &item ) );  // forcing const_cast WORKS
}

I have this sample code ( below ), example1() method works with no problem, example2() is similar but I must force const_char to make it compile, although I consider as example1() method is not needed, example2() would be not needed either.

My question is, how can I modify add() method to make both compile or how must I correctly call buffer.add() in example2() without forcing const_cast? add() method is not modifying item, so const_cast is unnecessary. Which is the correct or suitable form?

Here's the sample code:

template <class Item>
class Buffer
{
public:
    Item *      _pItems;
    int         _nItems;
    // ... constructor / destructors etc
    void    add( const Item & item ) // or maybe Item const & item
    {
        _pItems[_nItems++] = item;
    }
};
class MyClass
{
public:
    // data
};
void    example1( const MyClass & item )
{
    Buffer<MyClass>        buffer;
    buffer.add( item );  // WORKS, no problem
}
void    example2( const MyClass & item )
{
    Buffer<MyClass *>        buffer; // NOW with pointers to MyClass
    //buffer.add( item );  // ERROR: 'Buffer<Item>::add' : cannot convert parameter 1 from 'const MyClass' to 'MyClass *const &'
    buffer.add( const_cast<MyClass *>( &item ) );  // forcing const_cast WORKS
}

如果你对这篇内容有疑问,欢迎到本站社区发帖提问 参与讨论,获取更多帮助,或者扫码二维码加入 Web 技术交流群。

扫码二维码加入Web技术交流群

发布评论

需要 登录 才能够评论, 你可以免费 注册 一个本站的账号。

评论(2

甜尕妞 2024-11-13 07:47:46

你应该这样做:

Buffer<MyClass const*> 

因为 const MyClass 上的 &item 是 Myclass const* 而不是 MyClass*

You should do something like :

Buffer<MyClass const*> 

because &item on a const MyClass is a Myclass const* not a MyClass*

唯憾梦倾城 2024-11-13 07:47:46

您的 Buffer 类模板可以被认为是正确的,而您的 example2 函数是不正确的。我将在此基础上继续。

example1 中,该函数有一个指向 MyClass 实例的 const 引用参数。然后,Bufferadd 方法复制实例的值,将其放置在自己的内存缓冲区中(我希望 Buffer 保留跟踪所有这些记忆)。因此,example 采用 const 引用的事实与 Buffer 无关,因为已创建值的副本。

example2 中,Bufferadd 方法获取指向 MyClass 实例的指针的副本并存储在它自己的内存缓冲区中。在 example2 中,您已将 Buffer 实例化为保存指向 MyClass 的非常量指针,因此这就是您应该提供的内容,因此 example2 应该是:

void example2( MyClass & item )
{
    Buffer<MyClass *> buffer; // NOW with pointers to MyClass
    buffer.add( &item );
}

现在,您必须知道,如果要使用 buffer,则 item 必须在内存中保持固定状态,直到您使用完毕为止。而在 example1 中,这些项目可能会消失,因为您已将副本安全地存储在 buffer 中。

Your Buffer class template can be considered to be correct and it is your example2 function which is incorrect. I'll proceed on that basis.

In example1, the function has a const reference parameter to an instance of a MyClass. The add method of Buffer then makes a copy of the value of the instance, placing it in its own memory buffer (I hope Buffer is keeping track of all of this memory). Therefore the fact that example takes a const reference is irrelevant to Buffer since a copy of the value is made.

In example2, the add method of Buffer is taking a copy of the pointer to the instance of MyClass and storing that in its own memory buffer. In example2 you have instantiated Buffer as holding non-const pointers to MyClass, so that is what you should be giving it, so example2 should be:

void example2( MyClass & item )
{
    Buffer<MyClass *> buffer; // NOW with pointers to MyClass
    buffer.add( &item );
}

Now, you must be aware that if buffer were to be used, the item must remain fixed in memory until you've finished with it. Whereas in example1, the items can go away since you've safely stored copies in buffer.

~没有更多了~
我们使用 Cookies 和其他技术来定制您的体验包括您的登录状态等。通过阅读我们的 隐私政策 了解更多相关信息。 单击 接受 或继续使用网站,即表示您同意使用 Cookies 和您的相关数据。
原文