2013-06-01 1 views
6

Согласно Википедии:Внешняя переменная, расположенная в функции?

http://en.wikipedia.org/wiki/External_variable

Внешняя переменная может быть объявлена ​​внутри функции.

Какова цель внешней переменной, объявляемой внутри функции? Должна ли она быть статичной?

+0

эти сообщения связаны: http://stackoverflow.com/questions/16459422/why-does-declaring-an-extern-variable-inside-main-works-but- not-define-it-in и http://stackoverflow.com/questions/9686198/what-is-the-use-of-declaring-a-static-variable-as-extern-inside-a-function – taocp

ответ

2

Единственное различие между объявлении внешней переменной в области видимости пространства имен:

extern int x; 

void foo() { 
    cout << x; 
} 

и объявить его в области видимости функции:

void foo() { 
    extern int x; 
    cout << x; 
} 

является то, что в последнем случае x является только видно внутри функция.

Все, что вы делаете, еще больше затягивает область применения декларации extern.


Вот аналогичный пример использования пространств имен:

в области видимости пространства имен:

#include <string> 
using std::string; 

void foo() { 
    string str1; 
} 

string str2; // OK 

В области видимости функции:

#include <string> 
void foo() { 
    using std::string; 
    string str1; 
} 

string str2; // Error - `using` not performed at this scope 
1

Внешняя декларация входит в функцию. Это просто означает, что никакие другие функции не видят переменную.

void func() 
{ 
    extern int foo; 
    foo ++; 
} 


void func2() 
{ 
    foo--;  // ERROR: undeclared variable. 
} 

В другом исходном файле:

int foo;  // Global variable. Used in the other source file, 
      // but only in `func`. 

Это просто способ «изолировать» переменную, так что это не случайно привыкают в тех местах, где не допускается быть использованным.

+0

Я не знаю 't получить, как это отличается от обычной локальной переменной ... Как «extern» делает его другим? – 0x499602D2

+0

@ 0x499602D2 'extern' сообщает компилятору, что« эта переменная определена где-то еще ». Он ничего не определяет, он просто объявляет. –

+0

@ 0x499602D2: он не определяет переменную; это _declares_, который существует в другом месте. Поэтому он не является «местным». –

4

Это позволяет ограничить доступ к глобальным в какой-то объем:

int main() 
{ 
    extern int x; 
    x = 42; //OKAY 
} 

void foo() 
{ 
    x = 42; //ERROR 
} 

int x; 
0

текст относится к не -defin Объявление функции внешней функции внутри. Extern Определения внутри функции являются незаконными.

Таким образом, объявление, не определяющее внешнюю переменную внутри функции, просто означает, что вы хотите использовать эту переменную внутри этой функции. Сама переменная должна быть глобальной переменной, определенной в другом месте.

В принципе, если вам не нужен доступ к этой глобальной переменной (определенной в другом месте) во всей единице перевода и просто нужно ее внутри этой функции, то неплохо было бы объявить ее локально.Таким образом, вы не загрязняете глобальное пространство имен идентификаторами, не требующими других функций.

+0

Если его нельзя использовать где-либо еще, можно ли утверждать, что это может быть локальная статическая переменная? Есть ли разница? – user997112

+0

@ user997112: Я не уверен, что вы подразумеваете под «его нельзя использовать нигде». Собственно, сама переменная * может * использоваться абсолютно где угодно. (В конце концов, это глобальная переменная.) Просто требуется отдельная декларация в других местах. – AnT

+0

В ответе выше выглядит, что переменная не может использоваться вне функции, из-за которой она внешне объявлена? – user997112

0

Ключевое слово extern говорит о том, что идентификатор имеет внешнюю связь. Это означает, что он связан с тем же именем в другом месте, где он объявлен с внешней связью. То есть разные экземпляры имени в разных местах относятся к одному и тому же объекту.

Объявление идентификатора внутри блока (включая блок, определяющий функцию) дает ему область блока. Объем этого экземпляра идентификатора заканчивается в конце блока.

Объединение extern с областью блока позволяет функции видеть внешний идентификатор без загромождения пространства имен других функций. (Тем не менее, часто бывает плохой практикой.)