Title.ru

мы можем изменить значение переменной const с помощью следующего кода:

const int x=5; 

printf("\nValue of x=%d",x);

*(int *)&x=7;

printf("\nNew value of x=%d",x);

В C++ с использованием Microsoft Visual Studio-2008

const int a = 3;    /* I promisse i won't change a */
int * ptr1  = const_cast<int*> (&a);
*ptr1 = 5;  /* I'm a liar, a is now 5 . It's not okay. */
cout << "a = " << a << "\n"; /* prints 3 */
int arr1[a]; /* arr1 is an array of 3 ints */

int temp = 2;
/* or, const volatile int temp = 2; */
const int b = temp + 1; /* I promisse i won't change b */
int * ptr2  = const_cast<int*> (&b);
*ptr2 = 5; /* I'm a liar, b is now 5 . It's okay. */
cout << "b = " << b << "\n"; /* prints 5 */
//int arr2[b]; /* Compilation error */

В C константная переменная может быть изменена с помощью ее указателя; однако это неопределенное поведение. Переменная const никогда не может использоваться как длина в объявлении массива.

В C++, если константная переменная инициализируется чистым константным выражением, то ее значение не может быть изменено с помощью указателя даже после попытки изменения, в противном случае константная переменная может быть изменена с помощью ее указателя.

Чистая интегральная константная переменная может использоваться как длина в объявлении массива, если ее значение больше 0.

Чистое постоянное выражение состоит из следующих операндов.

1. Числовой литерал (константа), например 2, 10,53.

2. Символьная константа, определяемая директивой #define.

3. Константа перечисления

4. Чистая константная переменная, т.е. константная переменная, которая сама инициализируется чистым константным выражением.

5. Неконстантные переменные или изменчивые переменные не допускаются.

Я искал, как конвертировать между константами, и нашел этот http://www.possibility.com/Cpp/const.html, возможно, он может быть кому-то полезен. :)

Я протестировал приведенный ниже код, и он успешно изменяет постоянные переменные-члены.

#include <iostream>

class A
{
    private:
        int * pc1;  // These must stay on the top of the constant member variables.
        int * pc2;  // Because, they must be initialized first
        int * pc3;  // in the constructor initialization list.
    public:
        A() : c1(0), c2(0), c3(0), v1(0), v2(0), v3(0) {}
        A(const A & other)
            :   pc1 (const_cast<int*>(&other.c1)),
                pc2 (const_cast<int*>(&other.c2)),
                pc3 (const_cast<int*>(&other.c3)),
                c1  (*pc1),
                c2  (*pc2),
                c3  (*pc3),
                v1  (other.v1),
                v2  (other.v2),
                v3  (other.v3)
        {
        }
        A(int c11, int c22, int c33, int v11, int v22, int v33) : c1(c11), c2(c22), c3(c33), v1(v11), v2(v22), v3(v33)
        {
        }
        const A & operator=(const A & Rhs)
        {
            pc1     =  const_cast<int*>(&c1);
            pc2     =  const_cast<int*>(&c2),
            pc3     =  const_cast<int*>(&c3),
            *pc1    = *const_cast<int*>(&Rhs.c1);
            *pc2    = *const_cast<int*>(&Rhs.c2);
            *pc3    = *const_cast<int*>(&Rhs.c3);
            v1      = Rhs.v1;
            v2      = Rhs.v2;
            v3      = Rhs.v3;
            return *this;
        }
        const int c1;
        const int c2;
        const int c3;
        int v1;
        int v2;
        int v3;
};

std::wostream & operator<<(std::wostream & os, const A & a)
{
    os << a.c1 << '\t' << a.c2 << '\t' << a.c3 << '\t' << a.v1 << '\t' << a.v2 << '\t' << a.v3 << std::endl;
    return os;
}

int wmain(int argc, wchar_t *argv[], wchar_t *envp[])
{
    A ObjA(10, 20, 30, 11, 22, 33);
    A ObjB(40, 50, 60, 44, 55, 66);
    A ObjC(70, 80, 90, 77, 88, 99);
    A ObjD(ObjA);
    ObjB = ObjC;
    std::wcout << ObjA << ObjB << ObjC << ObjD;

    system("pause");
    return 0;
}

Вывод консоли:

10      20      30      11      22      33
70      80      90      77      88      99
70      80      90      77      88      99
10      20      30      11      22      33
Press any key to continue . . .

Здесь недостаток в том, что вам нужно определить столько указателей, сколько у вас есть постоянных переменных-членов.

это создаст ошибку во время выполнения. Поскольку ИНТ является статическим . Необработанное исключение. Место записи нарушения прав доступа 0x00035834.

void main(void)
{
    static const int x = 5;
    int *p = (int *)x;
    *p = 99;                //here it will trigger the fault at run time
}

Окончательное решение: изменит const значение переменной;

cont int a = 10;
*(int*)&a= 5; // now a prints 5
// works fine.

#include<stdio.h>
#include<stdlib.h>

int main(void) {
    const int a = 1; //a is constant
    fprintf(stdout,"%d\n",a);//prints 1
    int* a_ptr = &a;
    *a_ptr = 4;//memory leak in c(value of a changed)
    fprintf(stdout,"%d",a);//prints 4
return 0;
}

Вероятно, вы захотите использовать const_cast:

int *ptr = const_cast<int*>(ptr_to_a);

Я не уверен на 100%, что это сработает, я немного ржавел в C/C++ :-)

Немного чтения для const_cast: http://msdn.microsoft.com/en-us/library/bz6at95h(VS.80).aspx

Вы пробовали это?

ptr = const_cast<int *>(ptr_to_a);

Это должно помочь ему скомпилировать, но на самом деле это не случайно из-за приведения.

Обратите внимание, что любая попытка отказаться от константности не определена стандартом. Из 7.1.5.1 стандарта:

За исключением того, что любой член класса, объявленный изменяемым, может быть изменен, любая попытка изменить константный объект во время его существования приводит к неопределенному поведению.

И сразу после того, как используется этот пример:

const int* ciq = new const int (3);     //  initialized as required
int* iq = const_cast<int*>(ciq);        //  cast required
*iq = 4;                                //  undefined: modifies a  const  object

Короче говоря, то, что вы хотите сделать, невозможно с использованием стандартного C++.

Далее, когда компилятор встречает объявление типа

const int a = 3; // I promisse i won't change a

можно заменить любое появление 'a' на 3 (фактически выполняя то же самое, что и #define a 3 )

Шаг, который вам не хватает, заключается в том, что вам не нужен указатель int *. Линия:

const int *ptr_to_a = &a; // I still promiss i won't change a;

на самом деле говорит, что вы не будете менять ptr_to_a, а не файл. Итак, если вы изменили свой код, чтобы он читался так:

const int a = 3; // I promise I won't change a
const int *ptr_to_a = &a; // I promise I won't change ptr_to_a, not a.

(*ptr_to_a) = 5; // a is now 5

a теперь 5. Вы можете изменить a через ptr_to_a без предупреждения.

РЕДАКТИРОВАТЬ:

Вышесказанное неверно. Оказывается, я запутал аналогичный трюк с shared_ptr, в котором вы можете получить доступ к необработанному указателю и изменить значение внутренних данных, не выдавая никаких предупреждений. То есть:

#include <iostream>
#include <boost/shared_ptr.hpp>

int main()
{
    const boost::shared_ptr<int>* a = new boost::shared_ptr<int>(new int(3));
    *(a->get()) = 5;
    std::cout << "A is: " << *(a->get()) << std::endl;

    return 0;
}

Изготовим 5.

Просто предположение, но часто возникает вопрос, почему нельзя преобразовать a int** в a const int**, что на первый взгляд кажется разумным (в конце концов, вы просто добавляете a const, что обычно нормально). Причина в том, что если бы вы могли это сделать, вы могли бы случайно изменить const объект:

const int x = 3;
int *px;
const int **ppx = &px;  // ERROR: conversion from 'int**' to 'const int**'
*ppx = &x;  // ok, assigning 'const int*' to 'const int*'
*px = 4;    // oops, just modified a const object

Это очень неинтуитивно понятный результат, но единственный способ убедиться, что вы не можете изменить const объект в этом случае (обратите внимание на отсутствие приведений типов), - это сделать строку 3 ошибкой.

Вам разрешено добавлять const без приведения только на ПЕРВОМ уровне косвенного обращения:

int * const *ppx = &px;  // this is ok
*ppx = &x;               // but now this is an error because *ppx is 'const'

В C++ невозможно изменить const объект без использования какого-либо типа. Вам нужно будет использовать либо приведение в стиле C, либо стиль C++, const_cast чтобы удалить const -ness. Любая другая попытка сделать это приведет к ошибке компилятора.

const int foo = 42;
const int *pfoo = &foo;
const void *t = pfoo;
void *s = &t; // pointer to pointer to int
int **z = (int **)s; // pointer to int
**z = 0;

В статье, которую вы просматривали, возможно, говорилось о разнице между

const int *pciCantChangeTarget;
const int ci = 37;
pciCantChangeTarget = &ci; // works fine
*pciCantChangeTarget = 3; // compile error

а также

int nFirst = 1;
int const *cpiCantChangePointerValue = &nFirst;
int nSecond = 968;

*pciCantChangePointerValue = 402; // works
cpiCantChangePointerValue = &ci; // compile error

По крайней мере, я припоминаю - у меня здесь нет ничего, кроме инструментов Java, поэтому не могу проверить :)

В глубине веков мы, палеопрограммисты, использовали ФОРТРАН. FORTRAN передал все свои параметры по ссылке и не выполнял никакой проверки типов. Это означало, что было довольно легко случайно изменить значение даже буквальной константы. Вы можете передать «3» подпрограмме, и она вернется измененной, и поэтому каждый раз, когда в вашем коде будет «3», он будет действовать как другое значение. Позвольте мне сказать вам, что эти ошибки было сложно найти и исправить.

Некоторые из этих ответов указывают на то, что компилятор может оптимизировать переменную 'a', поскольку она объявлена const . Если вы действительно хотите иметь возможность изменять значение, a вам нужно пометить его как volatile

  const volatile int a = 3; // I promise i won't change a
  int *ptr = (int *)&a;
  (*ptr) = 5; // I'm a liar, a is now 5

Конечно, объявление чего-то const volatile должно действительно показать, насколько это глупо.

#include<iostream>
int main( void )
{
   int i = 3;    
   const int *pi = &i;
   int *pj = (int*)&i;
    *pj = 4;

   getchar(); 
   return 0;  
}