web analytics
Sign In | Register
Welcome, Guest
1 2

Type Casting in C and C++

 Options
Previous Topic Next Topic
@2016-01-19 11:39:57

const_cast

This type of casting manipulates the constness of an object, either to be set or to be removed. For example, in order to pass a const argument to a function that expects a non-constant parameter:

// const_cast
#include <iostream>
using namespace std;

void print (char * str)
{
  cout << str << endl;
}

int main () {
  const char * c = "sample text";
  print ( const_cast<char *> (c) );
  return 0;
}
 

The result is:

sample text
@2016-01-19 11:43:31

Comparison and Recommendation

The following are some rules of thumb for conversion operators:

  • If you reduce cv-qualification, use const_cast.
  • If you downcast, and want run-time assurance that the cast is valid, use dynamic_cast.
  • If you reinterpret a bit pattern, and a pointer is involved, use reinterpret_cast.
  • If you engage in type punning, use reinterpret_cast.
  • For all other conversions, use static_cast.
  • Avoid C casts of the form (T) e and functional casts of the form T(e). The conversion operators are both more obvious and more precise.


 Use const_cast and reinterpret_cast as a last resort, since these operators present the same dangers as old style casts. However, they are still necessary in order to completely replace old style casts.
@2016-01-20 22:36:16

Using the Const_cast Operator in C++

The const_cast operator in C++ can be used to remove the const, volatile, and __unaligned attribute(s) from a class.

const_cast < type-id > ( expression )

A pointer to any object type or a pointer to a data member can be explicitly converted to a type that is identical except for the const, volatile, and __unaligned qualifiers. For pointers and references, the result will refer to the original object. For pointers to data members, the result will refer to the same member as the original (uncast) pointer to data member. Depending on the type of the referenced object, a write operation through the resulting pointer, reference, or pointer to data member might produce undefined behavior.

You cannot use the const_cast operator to directly override a constant variable's constant status.

You cannot use const_cast for any other types of casts, such as casting a base class pointer to a derived class pointer. If you do so, the compiler will report an error.

The const_cast operator converts a null pointer value to the null pointer value of the destination type.

Example  1

#include <iostream.h>

class CCTest {
public:
  void setNumber( int );
  void printNumber() const;
private:
  int number;
};

void CCTest::setNumber( int num ) { number = num; }

void CCTest::printNumber() const {
  cout << "
Before: " << number;
  const_cast< CCTest * >( this )->number--;
  cout << "
After: " << number;
}

void main() {
  CCTest X;
  X.setNumber( 8 );
  X.printNumber();
}

On the line containing the const_cast, the data type of the this pointer is const CCTest *. The const_cast operator changes the data type of the this pointer to CCTest *, allowing the member number to be modified. The cast lasts only for the remainder of the line on which it appears.

Example  2

Consider a function, f, which takes a non-const argument: 

    double f( double& d );

Say you wish to call f from another function g:

  void g (const double& d) { val = f(d); }

Because d is const and should not be modified, the compiler will complain because f may potentially modify its value. To get around this dilemma, use a const_cast:

  void g (const double& d)
   {
      val = f(const_cast<double&>(d));
   }

This strips away the ``const-ness'' of d before passing it to f.
Previous Topic Next Topic
1 2

Comments
You must Sign In to comment on this topic.


© 2024 Digcode.com