相关疑难解决方法(0)

在以下程序中,相同的内存位置如何保持不同的值？我正在使用g ++编译器.

码:

#include<iostream>
using namespace std;

int main()
{
   const int i=100;
   int *j = const_cast<int*>(&i);
   *j=1;

   cout<<"The value of i is:"<<i<<endl;
   cout<<"The value j holds:"<<*j<<endl;
   cout<<"The address of i is:"<<&i<<endl;
   cout<<"The address of j is:"< <j<<endl;

}

输出:

The value of i is:100
The value j holds:1
The address of i is:0xbffbe79c
The address of j is:0xbffbe79c

请考虑以下代码:

我声明一个新的引用结束赋值给一个via const_cast.然后我只是增加参考值打印地址和值.

#include <iostream>
using namespace std;
int main()
{
    const int a = 7;
    int &b = const_cast<int&>(a);
    ++b;
    cout<<"Addresses  "<<&a<<" "<<&b<<endl;
    cout<<"Values  "<<a<<" "<<b<<endl;
}

//output
Addresses  0x7fff11f8e30c 0x7fff11f8e30c
Values  7 8

如何在同一地址中有2个不同的值？

在C++中,可以const &改变的价值吗？

好吧,当然不能改变,可以吗？这const意味着什么.而且,听听Stroustrup:

甲const左值参考指的是恒定的,这是从视角的参照的用户的点不可变的.

但是这个怎么样？

#include <iostream>

int main() {
    int           a = 0;
    const int&    r = a;
    const int old_r = r;
    ++a;
    const int new_r = r;
    std::cout
      <<      "old_r == " << old_r
      << " but new_r == " << new_r << std::endl;
    return 0;
}

在我的机器上,这输出,old_r == 0 but new_r == 1.

这是我真正的问题.在上面的代码中,查看该行

    const int new_r = r;

只要

• 地址&new_r既不在此行也不在代码的其他地方提取
• 代码什么都没有volatile,

没有任何东西阻止优化编译器从合并old_r …

鉴于以下C++代码:

#include <iostream>

int main()
{
    const int i = 1;
    *const_cast<int*>(&i) = 1; // Not allowed but doesn't do anything?
    std::cout << i << "\n";
}

问题:上面的代码是否调用UB(未定义的行为)？我知道抛弃const并为iUB中的结果赋值,因为我们不允许更改const变量的值.但是,在上面的代码中,我实际上没有更改 - 的值i- 那么,这仍然是UB吗？

在不依赖的情况下const_cast，如何const 在之后而不是期间创建一个 C++ 数据成员，当计算多个数据成员需要一个计算成本高昂的中间值时，

下面的最小、完整、可验证的示例进一步解释了这个问题及其原因。为了避免浪费您的时间，我建议您首先阅读示例的两条注释。

#include <iostream>\n\nnamespace {\n\n    constexpr int initializer {3};\n    constexpr int ka {10};\n    constexpr int kb {25};\n\n    class T {\n    private:\n        int value;\n        const int a_;\n        const int b_;\n    public:\n        T(int n);\n        inline int operator()() const { return value; }\n        inline int a() const { return a_; }\n        inline int b() const { return b_; }\n        int &operator--();\n    };\n\n    T::T(const int n): value {n - 1}, a_ {0}, b_ {0}\n    {\n …

我们先看一下例子。

#include <iostream>
int main()
{
    const int constant = 1;
    const int* const_p = &constant;
    int* modifier = const_cast<int*>(const_p);
    *modifier = 100;
    std::cout << "constant: " << constant << ", *const_p=" << *const_p;
    //Output: constant: 1, *const_p=100
    return 0;
}

我不知道它在内存架构上是如何实现的。看来编译器在堆栈中占用了额外的内存空间，以便我们可以跟踪值为constant的“原始” 1，以及堆栈中值为 的新内存位置100。是吗？那么，const_cast确实会消耗额外的内存，这是初学者可能没有想到的吗？