C/C++：Const 结构中的指针

Question

如何强制函数 fn 中 obj->val1 指向的内存保持常量？

#include <iostream>

struct foo {
    int* val1;
    int* val2;
    int* val3;
};

void fn( const foo* obj )
{
    // I don't want to be able to change the integer that val1 points to
    //obj->val1 = new int[20]; // I can't change the pointer,
    *(obj->val1) = 20; // But I can change the memory it points to...
}

int main(int argc, char* argv[])
{
    // I need to be able to set foo and pass its value in as const into a function
    foo stoben;
    stoben.val1 = new int;
    *(stoben.val1) = 0;
    std::cout << *(stoben.val1) << std::endl; // Output is "0"
    fn( &stoben );
    std::cout << *(stoben.val1) << std::endl; // Output is "20"
    delete stoben.val1;
    return 0;
}

这里的代码非常不言自明。我需要能够创建一个非常量对象并用数据填充它，然后将其传递给无法修改该数据的函数。我该怎么办？

我知道我可以只传递一个 const int 指针，但理论上，这个类包含我在“fn”中也需要的几个其他指针。

谢谢，

格里夫

Answer 1

由于您标记为 C++，因此您可以将成员设为 private 并创建一个返回 const int * 的访问器。您最初可以通过构造函数或 friend 函数设置该成员。

Answer 2

我不是 C++ 人员，但在 C 中，我会通过两种不同的结构声明来处理这个问题，一种是公共的，一种是私有的：

#include <stdio.h>
#include <stdlib.h>

struct private_foo {
    int* val1;
    int* val2;
    int* val3;
};

struct public_foo {
    int const * const val1;
    int const * const val2;
    int const * const val3;
};


void fn( struct public_foo * obj )
{
    int local;
    *(obj->val1) = 20; // compile error
    obj->val1 = &local; // compile error
}

int main(int argc, char* argv[])
{
    // I need to be able to set foo and pass its value in as const into a function
    struct private_foo stoben;
    stoben.val1 = malloc(sizeof(int));
    if (!stoben.val1) { return -1; }
    *(stoben.val1) = 0;
    printf("%d", *(stoben.val1) );
    fn( (struct public_foo *) &stoben );
    printf("%d", *(stoben.val1) );
    free(stoben.val1);
    return 0;
}

当我尝试使用 GCC 编译上述内容时，我收到以下编译器错误，因为我'我试图修改只读内存：

temp.c: In function ‘fn’:
temp.c:20: error: assignment of read-only location
temp.c:21: error: assignment of read-only member ‘val1’

Answer 3

你真的不能。 const foo 指定里面的成员是 const，即它们是指向整数的常量指针，而不是指向常量整数的指针。

对此的正确解决方案是通过封装、隐藏这些成员并提供公共接口。如果您被禁止修改 struct foo，一个实用的解决方案是通过私有继承：

struct foo {
    int* val1;
    int* val2;
    int* val3;
};

struct constFoo : private foo {
public:
   const int* getVal1() { return val1; }
   const int* getVal2() { return val2; }
   const int* getVal3() { return val3; }
};

当然，您需要创建适当的构造函数等，以便可以设置原始 foo。