Is there a way to restrict a pointer from being modified by specific functions?

Question

This builds off of my previous question: Is this an appropriate use of const qualifiers in C?

In Vector.h:

typedef struct _Vector Vector;
Vector* vector_init(const UInt32 size);
void*  vector_get(const Vector *v, UInt32 idx);
void   vector_add(Vector *v, void* const elem);
void   vector_set(Vector *v, const UInt32 idx, void* const elem);
...etc

In Vector.c:

struct _Vector{
    UInt32 used;
    UInt32 size;
    void** arr;
};

Vector* vector_init(const UInt32 size){
    Vector* v = malloc(sizeof(Vector));
    v->used = 0;
    v->size = size;
    v->arr = malloc(size*sizeof(void*));
    return v;
}

void* vector_get(const Vector *v, const UInt32 idx){
    if ( idx >= v->used )
        exitAtError("Vector","Array out of bounds");
    return v->arr[idx];
}

void vector_add(Vector *v, void* const elem){
    if( v->used == v->size )
        vector_resize(v);
    v->arr[v->used++] = elem;
}
...etc

I want to prevent void** arr in _Vector from being accidentally modified by my implementation, as a warning/error at compile time. I can't make arr a const void** because I don't want the vector to be permanent, and want to avoid casting away constness.

The idea here is that used and size are data that are directly related to the scope of my functions, whereas arr is just a kind of metadata that I don't want to modify. arr is opaque, so I can't directly modify it, but I can cast it or directly overwrite in bad ways such as memcpy.

In this example it seems unnecessary to enforce this access since each function is straight-forward, but this example mostly for demonstration purposes.

I have two related questions that can be answered at the same time:

1. Is this access restriction possible with the language support in C, and if not, is the opaqueness of the pointer considered a strong enough discouragement of directly modifying the data?
2. Am I just chasing my tail here and instead should focus on generating code that is well documented and well structured, where this wouldn't even become an issue?

I see a related question was asked in: Is there a way to protect a class variable from being modified outside of a function

That user seems to be in a similar predicament in C#; my question #2 is relevant in that scenario.

EDIT: I think from everyone's input, it's becoming clear that I'm pushing the language outside of its original design by looking for some type of magical keyword to document things for me. Either hiding my data behind another abstraction, or structurally separating out my functionality to prevent the temptation to poke at the data, seems to be the best solutions.

Answer 1

struct _Vector
{
    UInt32 used;
    UInt32 size;
    void **arr;
};

...

void foo(Vector *v)
{
    //Data cannot be modified, but arr and arr[idx] can still be assigned.
    const void **arr = v->arr;

    /*
     * Only work with local variable "arr".
     */

    /* Since v->arr wasn't const in the first place, casting away
       "const" shouldn't be an issue. */
    v->arr = (void **)arr;
}

I'm guessing some variation of that will work for you. Otherwise, use the abstraction of getter and setter functions instead of assigning directly to structure members in every function. That way, you don't need to worry about it.

Answer 2

1. I believe you can do something like void* const. The const placement makes the pointer and the data the pointer points to immutable.

2. In my opinion (which isn't saying much), wanting the data of a pointer to not be modified seems like a reasonable desire, as it helps document what the code does with the data passed to it (not modify it).

Answer 3

Since you were looking for a solution either in C/C++, I created a layer of abstraction in C++ to protect the void** const arr as follows. Please check does it meet your requirement.

class  array{
       public:
        void setArray(void** key)
        {
            arr=key;
        }

        void** getArray()
        {
            return &(*arr);
        }
    private:
     void** arr;
};
struct Vector: public array{
    int  used;
    int  size;

};

Vector* vector_init(const int  size){
    Vector* v =(Vector*) malloc(sizeof(Vector));
    v->used = 0;
    v->size = size;
    void** tem=v->getArray();
    tem=(void**) malloc(size*sizeof(void*));
    v->setArray(tem);
     return v;
}

Demo: http://coliru.stacked-crooked.com/a/005b335e5fb372ce