Related Blog Items

• How is "const correctness" related to ordinary type safety?
• What's the difference between "const X* p", "X* const p" and "const X* const p"?
• What is allowed in C, but not in C++?
• Safe String Copy(strcpy) and Concatenate(strcat) Operations
• Reference Counting

A good thing. It means using the keyword const to prevent const objects from getting mutated.

For example, if you wanted to create a function f() that accepted a std::string, plus you want to promise callers not to change the caller’s std::string that gets passed to f(), you can have f() receive its std::string parameter…

• void f1(const std::string& s);      // Pass by reference-to-const
• void f2(const std::string* sptr);   // Pass by pointer-to-const
• void f3(std::string s);             // Pass by value

In the pass by reference-to-const and pass by pointer-to-const cases, any attempts to change to the caller’s std::string within the f() functions would be flagged by the compiler as an error at compile-time. This check is done entirely at compile-time: there is no run-time space or speed cost for the const. In the pass by value case (f3()), the called function gets a copy of the caller’s std::string. This means that f3() can change its local copy, but the copy is destroyed when f3() returns. In particular f3() cannot change the caller’s std::string object.

As an opposite example, if you wanted to create a function g() that accepted a std::string, but you want to let callers know that g() might change the caller’s std::string object. In this case you can have g() receive its std::string parameter…

• void g1(std::string& s);      // Pass by reference-to-non-const
• void g2(std::string* sptr);   // Pass by pointer-to-non-const

The lack of const in these functions tells the compiler that they are allowed to (but are not required to) change the caller’s std::string object. Thus they can pass their std::string to any of the f() functions, but only f3() (the one that receives its parameter “by value”) can pass its std::string to g1() or g2(). If f1() or f2() need to call either g() function, a local copy of the std::string object must be passed to the g() function; the parameter to f1() or f2() cannot be directly passed to either g() function. E.g.,

Naturally in the above case, any changes that g1() makes are made to the localCopy object that is local to f1(). In particular, no changes will be made to the const parameter that was passed by reference to f1().

source: USENET 

[tags]const correctness[/tags]

Popularity: 5%

You need to log on to convert this article into PDF

Related Blog Items

• How is "const correctness" related to ordinary type safety?
• What's the difference between "const X* p", "X* const p" and "const X* const p"?
• What is allowed in C, but not in C++?
• Safe String Copy(strcpy) and Concatenate(strcat) Operations
• Reference Counting

This entry was written by ponnada and posted on December 8, 2006 at 3:21 pm and filed under C Tidbits, Types, Declarations & Expressions. Bookmark the permalink. Follow any comments here with the RSS feed for this post. Post a comment or leave a trackback: Trackback URL.