Следующая строка выдаст сообщение об ошибке:
t2.Text = "Maddsf";
Причина : поскольку метод FindControl () предоставляет вам веб-элемент управления. Однако txtID не является веб-элементом управления, и поэтому метод FindControl () не может вернуть веб-элемент управления (в данном случае TextBox ) и вместо этого возвращает [ 1110] нулевое значение . То, что вы присвоили свойству Text элемента управления Literal lt , является текстовым полем ввода, которое будет успешно отображаться браузером. Однако ASP.NET не знает, что элемент управления существует.
Решение : По этой же причине вы сможете получить ссылку на элемент управления в JavaScript. Примерно так:
document.getElementById("txtID").value = "Maddsf";
необходимо выбросить constness:
linux ~ $ cat constTest.c
#include <stdio.h>
void modA( int *x )
{
*x = 7;
}
int main( void )
{
const int a = 3; // I promisse i won't change a
int *ptr;
ptr = (int*)( &a );
printf( "A=%d\n", a );
*ptr = 5; // I'm a liar, a is now 5
printf( "A=%d\n", a );
*((int*)(&a)) = 6;
printf( "A=%d\n", a );
modA( (int*)( &a ));
printf( "A=%d\n", a );
return 0;
}
linux ~ $ gcc constTest.c -o constTest
linux ~ $ ./constTest
A=3
A=5
A=6
A=7
linux ~ $ g++ constTest.c -o constTest
linux ~ $ ./constTest
A=3
A=3
A=3
A=3
также общий ответ не работает в g ++ 4.1.2
linux ~ $ cat constTest2.cpp
#include <iostream>
using namespace std;
int main( void )
{
const int a = 3; // I promisse i won't change a
int *ptr;
ptr = const_cast<int*>( &a );
cout << "A=" << a << endl;
*ptr = 5; // I'm a liar, a is now 5
cout << "A=" << a << endl;
return 0;
}
linux ~ $ g++ constTest2.cpp -o constTest2
linux ~ $ ./constTest2
A=3
A=3
linux ~ $
btw.. это никогда не рекомендуется... Я нашел, что g ++ не позволяет этому происходить.. таким образом, это может быть проблемой, которую Вы испытываете.
Шаг, который Вы пропускаете, - то, что Вам не нужен интервал* указатель. Строка:
const int *ptr_to_a = &a; // I still promiss i won't change a;
на самом деле говорит, что Вы не измените ptr_to_a, не 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
теперь 5. Можно измениться через 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.
Вы, вероятно, хотите использовать const_cast:
int *ptr = const_cast<int*>(ptr_to_a);
я не на 100% уверен, что это будет работать, хотя, я немного ржав в C/C++:-)
Некоторый readup для const_cast: http://msdn.microsoft.com/en-us/library/bz6at95h (По сравнению с 80) .aspx
Вы пробовали это?
ptr = const_cast<int *>(ptr_to_a);
, Который должен помочь ему скомпилировать, но это не происходит действительно случайно из-за броска.
Назад в туманах времени, мы палеопрограммисты использовали ФОРТРАН. ФОРТРАН Передал все свои параметры ссылкой и не сделал никакого typechecking. Это означало, что было довольно легко случайно изменить значение даже литеральной константы. Вы могли передать "3" ПОДПРОГРАММЕ, и она возвратится измененная, и таким образом, каждый раз с тех пор, где Ваш код имел "3", он будет на самом деле действовать как различное значение. Позвольте мне сказать Вам, это были трудные ошибки, чтобы найти и зафиксировать.
Обратите внимание, что любая попытка выбросить constness не определена по стандарту. Из 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
, это свободно заменить любое происшествие с 3 (эффективно выполнение того же самого как #define a 3
)
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 здесь, так не может протестировать:)
Некоторые из этих ответов указывают, что компилятор может оптимизировать далеко переменную, так как это объявляется 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
должен действительно проиллюстрировать, насколько глупый это.
Просто предположение, но общий вопрос - то, почему нельзя преобразовать int**
в const int**
, который сначала, кажется, разумен (в конце концов, Вы просто добавляете 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-стиля или в стиле С++ const_cast
для удаления const
- мыс. Любая другая попытка сделать так приведет к ошибке компилятора где-нибудь.
#include<iostream>
int main( void )
{
int i = 3;
const int *pi = &i;
int *pj = (int*)&i;
*pj = 4;
getchar();
return 0;
}