how to protect array field form changing in one function

[umka6970]

There is const keyword and it is simply to protect an argument of a function form changing. An example:

void func(const int& arg)
{
   arg++; // ERROR: it is illegal
}

Let we have a class "Type" and function "chg_elem":

class Type {
public:
	int* array;
};

void chg_elem(const Type& obj) 
{
	obj.array = {1,2,4}; // ERROR: it is illegal
	obj.array[0] = 1; // NOT AN ERROR: why?
}

The quastion is why is line №9 legal and how to protect the array field form changing?

[Ganado]

privyet :) The problem stems from the fact that a pointer is not an array.
Line 9 does not change the pointer "array" in any way - it is only changing the data that the pointer is pointing to.

Also, line 8 is not valid syntax, because {...} braces can only be used when initializing the variable, not assigning to it. If you want to make array point to an actual array, you'd have to either point to an already-existing array, or dynamically allocate an array using new[].

One way to fix your immediate problem is to declare your pointer as const int* array;

EDIT: Fixed typo, added info.

[umka6970]

privet :)

yes, it is my mistake, I meant another. Let the code be

class Type {
    public:
    int* array;
};

void chg_elem(const Type& obj) 
{
    int new_array[] = {1,2,3};
    obj.array = new_array; // ERROR: it is illegal
    obj.array[0] = 1; // NOT AN ERROR: why?
}

It is not suitable for the case - I will not be able to change it at all - not only in "chg_elem" function.
Thank you for help. Can I have an advice how to modify the code to protect everything from changing in "chg_elem"?

[Ganado]

I don't think you can have it both ways, at least not with public access that any outside function could reach, if I understand correctly.

You can make int* array be private and provide accessors and setters, similar to what an std::vector<int> does.

[umka6970]

You see now we have this:

class Type {
public:
	const int* array;
};

void chg_elem(const Type& obj) 
{
	int new_array[] = {1,2,3};
	obj.array = new_array; // ERROR: illegal
	obj.array[0] = 1; // ERROR: illegal
}

void set_elem(Type obj)
{
	int new_array[] = { 1, 2, 3 };
	obj.array = new_array; // WORKS: legal
	obj.array[0] = 1; // ERROR: illegal
}

Is there a way to make line №17 legal too? The idea is to be sure that function "new_array" can't change anything but function "set_elem" must have the access :)

[Ganado]

Very sorry for the confusion. I edited my post after I realized my mistake.

Maybe someone more powerful than me knows a secret, but you're seeing the problem with public access: Any function can do anything it wants to your variable. I don't know of an elegant way to do that without making array be private.

[umka6970]

Ok. I get your idea and I am sorry to - not accurate explanation, i tried to simplify. In the real code I need an encapsulated functions that must be invoked without object

Type::func(const Type& obj) // like this
obj.func(void) // not like this 

It is static function as I know. But it cause the problem: can't be sure that the object is really constant... Is it bad programming style? :(