CODEWITHSUNDEEP
c++constants
Vijay
Vijay

Reputation: 67211

Const variables in c++

AFAIK we cannot change a value of a constant variable in C. But i faced this interview question as below:

In C++, we have procedure to change the value of a constant variable. Could anybody tell me how could we do it?

Upvotes: 2

Views: 698

Answers (6)

Throwback1986
Throwback1986

Reputation: 5995

If a const variable requires a change in value, then you have discovered a flaw in the design (under most, if not all, situations). If the design is yours, great! - you have an opportunity to improve your code.

If the design is not yours, good luck because the UB comment above is spot-on. In embedded systems, const variables may be placed in ROM. Performing tricks in an attempt to make such a variable writable lead to some spectacular failures. Furthermore, the problem extends beyond simple member variables. Methods and/or functions that are marked const may be optimized in such away that "lack of const-ness" becomes nonsensical.

(Take this "comment-as-answer" as a statement on the poor interview question.)

Upvotes: 0

Erik
Erik

Reputation: 91260

The interviewer was looking for const_cast. As an added bonus, you can explain scenarios where const_cast make sense, such as const_cast<MyClass *>(this)->doSomething() (which can be perfectly valid, although IMO not very clean), and scenarios where it can be dangerous , such as casting away constness of a passed const reference and therefore breaking the contract your functions signature provides.

Upvotes: 0

Jerry Coffin
Jerry Coffin

Reputation: 490008

Under the circumstances, I think I'd have explained the situation: attempting to change the value of a variable that's const gives undefined behavior. What he's probably asking about is how to change a variable that isn't itself const, but to which you've received a pointer or reference to const. In this case, when you're sure the variable itself is not const-qualified, you can cast away the const-ness with const_cast, and proceed to modify.

If you do the same when the variable itself is const-qualified the compiler will allow the code to compile, but the result will be undefined behavior. The attempt at modifying the variable might succeed -- or it might throw an exception, abort the program, re-format your NAS appliance's hard drives, or pretty much anything else.

It's probably also worth mentioning that when/if a variable is likely to need to be used this way, you can specify that the variable itself is mutable. This basically means that the variable in question is never const qualified, even if the object of which it's a part is const qualified.

Upvotes: 7

Sarfaraz Nawaz
Sarfaraz Nawaz

Reputation: 361264

You cannot change the value of a constant variable. Trying to do so by cheating the compiler, invokes undefined behavior. The compiler may not be smart enough to tell you what you're doing is illegal, though!

Or maybe, you mean this:

const char *ptr= "Nawaz";
ptr = "Sarfaraz";

??

If so, then it's changing the value of the pointer itself, which is not constant, rather the data ptr points to is constant, and you cannot change that for example by writing ptr[2]='W';.

Upvotes: 3

James McNellis
James McNellis

Reputation: 354969

You can modify mutable data members of a const-qualified class-type object:

struct awesome_struct {
    awesome_struct() : x(0) { }
    mutable int x;
};

int main() {
    const awesome_struct a;
    a.x = 42;
}

The behavior here is well-defined.

Upvotes: 8

Prasoon Saurav
Prasoon Saurav

Reputation: 92854

There is no perfect way to cast away const-ness of a variable(which is const by definition) without invoking UB

Most probably the interviewers have no idea what they are talking about. ;-)

Upvotes: 6

Related Questions