int x;
/* в файле y.c: */
int x;
Ни компилятор языка С, ни компилятор языка С++ не найдет никаких ошибок в файлах
x.c
или
y.c
. Но если файлы
x.c
и
y.c
скомпилировать как файлы на языке С++, то редактор связей выдаст сообщение об ошибке, связанной с двойным определением. Если же файлы
x.c
и
y.c
скомпилировать на языке C, то редактор связей не выдаст сообщений об ошибке и (в полном соответствии с правилами языка C) будет считать, что речь идет об одной и той же переменной
x
, совместно используемой в файлах
x.c
и
y.c
. Если хотите, чтобы в программе всеми модулями совместно использовалась одна глобальная переменная
x
, то сделайте это явно, как показано ниже.
/* в файле x.c: */
int x = 0; /* определение */
/* в файле y.c: */
extern int x; /* объявление, но не определение */
Впрочем, лучше используйте заголовочный файл.
/* в файле x.h: */
extern int x; /* объявление, но не определение */
/* в файле x.c: */
#include "x.h"
int x = 0; /* определение */
/* в файле y.c: */
#include "x.h"
/* объявление переменной x находится в заголовочном файле */
А еще лучше: избегайте глобальных переменных.
27.3.4. Приведение типов в стиле языка С
В языке C (и в языке C++) можете явно привести переменную
v
к типу
T
, используя минимальные обозначения.
(T)v
Это так называемое “приведение в стиле языка С”, или “приведение в старом стиле”. Его любят люди, не умеющие набирать тексты (за лаконичность) и ленивые (потому что они не обязаны знать, что нужно для того, чтобы из переменной
v
получилась переменная типа
T
). С другой стороны, этот стиль яростно отвергают программисты, занимающиеся сопровождением программ, поскольку такие преобразования остаются практически незаметными и никак не привлекают к себе внимания. Приведения в языке С++ (
приведения в новом стиле (new-style casts), или
приведения в шаблонном стиле (template-style casts); см. раздел А.5.7) осуществляют явное преобразование типов, которое легко заметить. В языке С у вас нет выбора.
int* p = (int*)7; /* интерпретирует битовую комбинацию:
reinterpret_cast<int*>(7) */
int x = (int)7.5; /* усекает переменную типа: static_cast<int>(7.5) */
typedef struct S1 { /* ... */ } S1;
typedef struct S2 { /* ... */ } S2;
S1 a;
const S2 b; /* в языке С допускаются неинициализированные
/* константы */
S1* p = (S2*)&a; /* интерпретирует битовую комбинацию:
reinterpret_cast<S1*>(&a) */
S2* q = (S2*)&b; /* отбрасывает спецификатор const:
const_cast<S2*>(&b) */
S1* r = (S1*)&b; /* удаляет спецификатор const и изменяет тип;
похоже на ошибку */
Мы не рекомендуем использовать макросы даже в программах на языке C (раздел 27.8), но, возможно, описанные выше идеи можно было бы выразить следующим образом:
#define REINTERPRET_CAST(T,v) ((T)(v))
#define CONST_CAST(T,v) ((T)(v))
S1* p = REINTERPRET_CAST (S1*,&a);
S2* q = CONST_CAST(S2*,&b);
Это не обеспечит проверку типов при выполнении операторов
reinterpret_cast
и
const_cast
, но сделает эти ужасные операции заметными и привлечет внимание программиста.
27.3.5. Преобразование указателей типа void*
В языке указатель типа
void*
можно использовать как в правой части оператора присваивания, так и для инициализации указателей любого типа; в языке C++ это невозможно. Рассмотрим пример.
void* alloc(size_t x); /* выделяет x байтов */
void f (int n)
{
int* p = alloc(n*sizeof(int)); /* OK в языке C;
ошибка в языке C++ */
/* ... */
}
Здесь указатель типа
void*
возвращается как результат функции
alloc()
и неявно преобразовывается в указатель типа
int*
. В языке C++ мы могли бы переписать эту строку следующим образом:
int* p = (int*)alloc(n*sizeof(int)); /* OK и в языке C,
и в языке C++ */
Мы использовали приведение в стиле языка C (раздел 27.3.4), чтобы оно оказалось допустимым как в программах на языке C, так и в программах на языке C++.
Почему неявное преобразование
void*
в
T*
является недопустимым в языке С++? Потому, что такие преобразования могут быть небезопасными.
