Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://en.cppreference.com/w/cpp/language/../../cpp/language/const_cast.html below:

const_cast conversion - cppreference.com

Converts between types with different cv-qualification.

Returns a value of type target-type.

Only the following conversions can be done with const_cast:

For two

object pointer or pointer to data member types

and

, a prvalue of type

can be converted to

if

and

differ only in cv-qualification (formally, if, considering the

of both types, each

is the same as

for all

).

• If expression is a null pointer value, the result is also a null pointer value.
• If expression is a null member pointer value, the result is also a null member pointer value.
• If expression points to an object, the result points to the same object.
• If expression points past an object, the result points past the same object.
• If expression points to a data member, the result points to the same data member.

For two

and

, if a pointer to

can be explicitly converted to the type “pointer to

” using

, then the following conversions can also be made:

• An lvalue of type T1 can be explicitly converted to an lvalue of type T2 using const_cast<T2&>.

• A glvalue of type T1 can be explicitly converted to an xvalue of type T2 using const_cast<T2&&>.
• If T1 is a class or array type, a prvalue of type T1 can be explicitly converted to an xvalue of type T2 using const_cast<T2&&>.

The result reference refers to the original object.

If expression is a glvalue, the result reference refers to the original object. Otherwise, the result reference refers to the materialized temporary.

As with all cast expressions, the result is:

• an lvalue if target-type is an lvalue reference type or an rvalue reference to function type(since C++11);

• an xvalue if target-type is an rvalue reference to object type;

• a prvalue otherwise.

For two different types T1 and T2, a conversion from T1 to T2 casts away constness if there exists a qualification-decomposition of T2 of the form “cv2_0 P2_0 cv2_1 P2_1 ... cv2_n−1 P2_n−1 cv2_n U2”, and there is no qualification conversions that converts T1 to “cv2_0 P1_0 cv2_1 P1_1 ... cv2_n−1 P1_n−1 cv2_n U1” (same cv-components, different P-components and U-components).

If a cast from a prvalue of type T1* to the type T2* casts away constness, casting from an expression of type T1 to a reference to T2 will also cast away constness.

Only const_cast may be used to cast away constness.

“Casting away constness” implies “casting away volatility”, as qualification conversions cannot cast away volatility as well.

Pointers to functions and pointers to member functions are not subject to const_cast.

const_cast makes it possible to form a reference or pointer to non-const type that is actually referring to a const object or a reference or pointer to non-volatile type that is actually referring to a volatile object. Modifying a const object through a non-const access path and referring to a volatile object through a non-volatile glvalue results in undefined behavior.

const_cast

#include <iostream>
 
struct type
{
    int i;
 
    type(): i(3) {}
 
    void f(int v) const
    {
        // this->i = v;                 // compile error: this is a pointer to const
        const_cast<type*>(this)->i = v; // OK as long as the type object isn't const
    }
};
 
int main()
{
    int i = 3;                 // i is not declared const
    const int& rci = i;
    const_cast<int&>(rci) = 4; // OK: modifies i
    std::cout << "i = " << i << '\n';
 
    type t; // if this was const type t, then t.f(4) would be undefined behavior
    t.f(4);
    std::cout << "type::i = " << t.i << '\n';
 
    const int j = 3; // j is declared const
    [[maybe_unused]]
    int* pj = const_cast<int*>(&j);
    // *pj = 4;      // undefined behavior
 
    [[maybe_unused]]
    void (type::* pmf)(int) const = &type::f; // pointer to member function
    // const_cast<void(type::*)(int)>(pmf);   // compile error: const_cast does
                                              // not work on function pointers
}

Output:

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

• C++23 standard (ISO/IEC 14882:2024):

• 7.6.1.11 Const cast [expr.const.cast]

• C++20 standard (ISO/IEC 14882:2020):

• 7.6.1.10 Const cast [expr.const.cast]

• C++17 standard (ISO/IEC 14882:2017):

• 8.2.11 Const cast [expr.const.cast]

• C++14 standard (ISO/IEC 14882:2014):

• 5.2.11 Const cast [expr.const.cast]

• C++11 standard (ISO/IEC 14882:2011):

• 5.2.11 Const cast [expr.const.cast]

• C++98 standard (ISO/IEC 14882:1998):

• 5.2.11 Const cast [expr.const.cast]

• C++03 standard (ISO/IEC 14882:2003):

• 5.2.11 Const cast [expr.const.cast]

• static_cast
• dynamic_cast
• reinterpret_cast
• explicit cast
• implicit conversions

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4