Защо константен указател не може да бъде константен израз?

Това е малко по-сложно. В C++03 и C++11 &var е постоянен израз, ако var е локална статична/статична класа или променлива за обхват на пространството от имена. Това се нарича константен израз на адрес. Инициализирането на статична променлива на указател на обхвата на клас или пространство от имена с този постоянен израз е гарантирано, че ще бъде направено преди да се изпълни какъвто и да е код (фаза на статична инициализация), тъй като това е постоянен израз.

Въпреки това само от C++11 насам, променлива за указател на constexpr, която съхранява адреса &var, също може да се използва като израз на константа на адрес и само от C++11 насам можете да дереферирате израз на константа на адрес (всъщност , можете да дереферирате дори повече - дори локални адреси на елемент от масив, но нека го запазим по темата) и ако се отнася до постоянна интегрална променлива, инициализирана преди дереферирането, или променлива constexpr, вие отново получавате постоянен израз (в зависимост от типа и стойностна категория, видът на константния израз може да варира). Като такъв, следното е валидно C++11:

int const x = 42;
constexpr int const *px = &x;

// both the value of "px" and the value of "*px" are prvalue constant expressions
int array[*px];
int main() { return sizeof(array); }

Ако е така, защо указателят да не може да бъде константен израз? Ако не, защо горните програми не се компилират?

Това е известно ограничение във формулировката на стандарта - в момента той позволява само други параметри на шаблона като аргументи или & object за параметър на шаблон от тип указател. Въпреки че компилаторът трябва да може да прави много повече.

Все още не е разрешено в C++0x. temp.arg.nontype изисква:

Аргумент-шаблон за параметър-шаблон, който не е тип, не е шаблон, трябва да бъде едно от:

• за шаблонен параметър без тип от интегрален или изброен тип, преобразуван константен израз (5.19) от типа на шаблонния параметър; или
• името на шаблон-параметър без тип; или
• постоянен израз (5.19), който обозначава адреса на обект със статична продължителност на съхранение и външна или вътрешна връзка или функция с външна или вътрешна връзка, включително шаблони на функции и идентификатори на шаблони на функции, но с изключение на нестатични членове на класа, изразено (без да се вземат предвид скобите) като & id-expression, с изключение на това, че & може да бъде пропуснато, ако името се отнася до функция или масив и трябва да бъде пропуснато, ако съответният параметър на шаблона е препратка; или
• постоянен израз, който дава стойност на нулев указател (4.10); или
• постоянен израз, който се оценява на нулева стойност на указател на член (4.11); или
• указател към член, изразен, както е описано в 5.3.1.

оригинален отговор:

1. В C++03 само интегралните изрази могат да бъдат константни изрази.
2. Защото стандартът го казва (естествено).
3. В C++0x n3290 включва примери с използване на constexpr върху указател. Така че това, което опитвате, сега трябва да е възможно, въпреки че сега трябва да използвате ключовата дума constexpr вместо const от най-високо ниво.

Има и включена грешка в gcc, g++ отхвърля собствените примери на стандартната чернова за валидно constexpr използване.

Проблемът е, че вашата C++ програма може да бъде заредена във всяка точка на паметта и така адресът на глобален var може да е различен всеки път, когато стартирате програмата. Какво се случва, ако стартирате програмата си два пъти? Тогава var очевидно е на две различни места.

Дори по-лошо, във вашия пример вие вземате адреса на променлива в стека! виж това:

void myfunction( unsigned int depth) {
     const int myvar = depth;
     const int * const myptr = &myvar;
     if (depth)
         myfunction(depth-1);
}

Ако main извиква myfunction(3), тогава 3 myvars се създават на отделни места. Няма начин времето за компилиране дори да знае колко много myvars са създадени, още по-малко има точни местоположения.

И накрая: декларирането на променлива като const означава: "Обещавам" и не означава, че това е константа за време на компилиране. Вижте този пример:

int main(int argc, char** argv) {
    const int cargc = argc;
    char* myargs[cargc]; //the size is constant, but not a _compile time_ constant.
}