идентификаторы

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

{

int a=2; // а – вне блока

cout<<a<<endl; // печать 2

{

int a=7;

cout<<a<<endl; //печать 7

}

cout<<++a<<endl; //напечатается 3

}

В Си++ область видимости идентификатора начинается сразу после его объявления и продолжается до конца самого внутреннего блока, в котором он объявлен.

 

Рассмотрим пример 7.6 (стр.5)

// Не конфликтующие локальные переменные

 

#include <stdio.h>

#include <conio.h>

 

void Pause(void);

void Function1(void);

void Function2(void);

 

main()

{

Function1();

return 0;

}

 

void Pause(void)

{

printf("Press <SpaceBar> to continue...");

while (getch() != ' ') ;

}

 

void Function1(void);

{

char s[15] = "Philadelphian"

 

printf("nBegin function #1. s = %s", s);

Pause();

Function2();

printf("nBack in function #1. s = %s", s);

}

 

void Function2(void)

{

char s[15] = "San Franciscon"

 

printf("Begin function #2. s = %s", s);

Pause();

}

 

Класс памяти auto

Переменные имеют два атрибута:

 

тип и класс памяти:

auto – автоматический

extern – внешний

register – регистровый

static – статический

volatile – непостоянный для Borland

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

{

auto int a, b, c;

auto float f=7.7;

}

Система выделяет память, для автоматических переменных при входе в блок. Переменные с инициализаторами инициализируются. Обычно для таких переменных используется та или иная форма размещения в стеке. Например, для предыдущего блока.

Стек до блока Вошли в блок Вышли из блока

Класс памяти register

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

Например,

 

{ for(register i=0; i<LIMIT; i++)

{…

}

Вообще этот класс компилятор воспринимает как рекомендацию. Поэтому, если мы написали register, это вовсе не значит, что переменная действительно будет в регистре.

Для явного указания того, чтобы переменная не была размещена в регистре используется слово volatile (для компилятора Borland)

 

Рассмотрим пример 7.7 стр(6)

/* Переменные классов registers и volatole */

 

#include <stdio.h>

 

void UseRegister(void);

void UseVolatile(void);

 

main()

{

UseRegister();

UseVolatile();

return 0;

}

 

void UseRegister(void)

{

register int k;

 

printf("nCounting with a register variablen");

for (k =1; k <= 100; k++)

printf("%8d", k);

}

 

void UseVolatile(void)

{

volatile int k;

 

printf("nCounting with a volatile variablen");

for (k = 1; k <= 100; k++)

printf("%8d", k);

}

 

Класс памяти extern.

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

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

Пример.

Файл circle 3.cpp

const double pi=3.14; //локальна по отношению к circle 3.cpp

double circle (double radius)

{return (pi*radius*radius);

}

файл cir_main.cpp

#include <iostream.h>

double circle (double); //внешняя функция автома.

Int main ()

{

double x

. . . .

cout<<circle (x)<<”- площадь круга радиуса”

<<x<<endl;

}

Рассмореть 7.8, 7.9

/* Внешние переменные - часть 1 */

 

#include <stdio.h>

 

void GetFloat(void);

 

float f;

 

main()

{

GetFloat();

printf("Value of float = %fn", f);

return 0;

}

/* Внешние переменные - часть 2 */

 

#include <stdio.h>

 

void GetFloat(void)

{

extern float f;

 

printf("Enter floating point value: ");

scanf("%f", &f);

}

 

Класс памяти static

Статические переменные имеют два важных применения.

1. Локальная статическая переменная сохраняет предыдущее значение при повторном входе в блок.

Пример.

 

Int f ()

{

static int called=0;

++called;

. . . .

return called;

}

Область действия статических переменных ограничена функцией, в которой она объявлена.

2. Статические функции видны только внутри файла, в котором они определены. В отличии от обычных функций, к которым возможен доступ из других файлов, статическая функция доступна только в своем файле.

 

static int goo (int a)

{

. . . .

}

int foo (int a)

{

. . . .

b=goo (a); //goo доступна только в этом файле

. . . .

}

(7.10) что делает эта программа.

/* Статические переменные */

 

#include <stdio.h>

 

int Next1(void);

int Next2(void);

 

main()

{

int i;

 

printf("nCalling Next1():n");

for (i = 1; i <= 10; i++)

printf(" %d", Next1());

printf("nCalling Next2():n");

for (i = 1; i <= 10; i++)

printf(" %d", Next2());

return 0;

}

 

int Next1(void)

{

static int value = 1; /* Static variable */

 

return value++;

}

 

int Next2(void)

{

int value = 1; /* Normal local variable */

 

return value++;

}

 

Некоторые особенности компоновки.

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

Программы на Си++ могут компоноваться с программами на Си на Паскале, в зависимости от реализации.

Пространство имен.

Си++ унаследовал от Си единое пространство имен. Возникающие из-за этого конфликты привели к появлению в Си++ области видимости пространства имен.

Namespace LMPinc

{

class purrles{…};

class toys{…};

. . . .

}

Идентификатор пространства имен может быть использован, как часть идентификатора, разрешающего область видимости. Идентификатор_пространства_имен :: идентификатор

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

 

using namespace LMPinc;

toys top; //используется LMPinc :: toys

Пространства имен могут быть вложенными.

 

namespase LMPout

{

int n;

namespace LMPin

{

int sq()

{

return n*n;

} //LMPout :: n

void pr_mu_logo():

}

void LMPin :: pr_mu_logo()

{

cout<<”LMPinc”<<eldl;

}

}

Вместо глобальных статических переменных может использоваться безымянное пространство имен. Например,

 

Namespace

{

int count=0;

} //здесь count уникальный.

// count доступна в остальной части файла

void chg_cnt(int i)

{

count=i;

}

Перечислимые типы.

Ключевое слово enum используется для объявления особого целого типа с набором именованных целых констант, называемых константами перечислимого типа или перечислимыми константами.

enum suit {clubs, diamonds, hearts, spides};

0 1 2 3

по умолчанию

Перечислимые константы могут быть инициализированы произвольными целыми константами, а также целыми выражениями

enum ages {laura=7, ira=8, harold=59, philip=harold+7};

66

Теговые имена и имена перечислимых констант должны быть уникальны в пределах области видимости.

Перечислимые константы могут быть преобразованы к обычному целому типу, но не наоборот.

 

enum signal {off,on}a=on; //a присвоено значение on=1

enum answer {no, yes, maybe=-1}b;

enum negative {no, false}c; //недопустимо no и false переобъяв- лены

int i, j=on; //допустимо

a=off; //допустимо

i=a; //допустимо

b=a; // недопустимо, разные типы

b=static_cast<answer>(a); //допустимо

b=(a? No : yes);

Типы указателей.

Указатели в Си++ используются для связи переменных с «машинными» адресами.

Если v – переменная, то &v – это адрес, или место в памяти, где хранится ее значение.

Пример объявления указателя на целое

 

Int*p;

Допустимая область значений:

- специальный адрес 0 (обычно для указания ошибки)

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

Примеры присваивания значений.

 

p=&i; // адрес объекта i

p=0; // нулевое значение

p=static_cast<int*> (1507); // абсолютный адрес

 

/* об'явление, инициализация и разыменовывание указателя */

 

#include <stdio.h>

 

char c; /* Символьная переменная */

 

main()

{

char *pc; /* Указатель на символьную переменную */

 

pc = &c;

for (c = 'A'; c <= 'Z'; c++)

printf("%c", *pc);

return 0;

}

 

 

Определение адреса и разыменования.

Если p – указатель, то *р – это значение, находящееся по адресу, который хранится в указателе р.

Рассмотрим примеры:

 

Int i=5;j;

Int*p=8i; //указатель инициализирован адресом переменной i

Cout<<*p<<”=i, хранится по адресу”endl;

J=p: // недопустимо, указатель не преобразуется в целое

J=*p+1; //допустимо

p=8j; // теперь р указывает на j

При обращении к функции указатели могут передаваться в качестве аргументов.

 

//вызов по ссылке на основе указателей

void order (int*, int*);

int main()

{ int i=7, j=3;

cout<<i<<’t’<<j<<endl; //напечатается 7и3

order (&, &j );

cout<<i<<’t’<<j<<endl; //напечатаются 3 7

}

void order (int*p, int*q)

{ int temp;

if (*p>*q) {

temp=*p;

*p=*q;

*q=temp;

}

}

Применение void.

Ключевое слово void используется как возвращаемый тип функции, не возвращающей значения. Для указателей void используется для объявления обобщенного указателя (void*p;). Такому указателю можно присвоить адрес переменной любого типа, но он не может быть разыменован.

 

void*gp; // обобщенный указатель

int*ip; // указатель на int

char*cp // указатель char

gp=ip; // допустимо

cp=ip // не допустимо

*ip=15 // допустимо

*ip=*gp; // недопустимо разыменование gp

ip=static_cast<int*>(gp); //допустимо

Рассмотрим еще пример 9.2.

/* использование указателя на void для адресации буфера */

 

#include <stdio.h>

#include <dos.h>

 

void DispPointer(void *p);

 

main()

{

char buffer[1024];

void *bp;

 

bp = &buffer; /* присваивание адреса буфера указателю bp */

*(char *)bp = 'A'; /* запоминание символа через указатель */

buffer[1] = 'B'; /* прямое запоминание символа */

buffer[2] = 0; /* вставка нуля после "AB" */

printf("Address of buffer == ");

DispPointer(&buffer);

printf("Data in buffer == %s", (char *)bp);

return 0;

}

 

void DispPointer(void *p)

{

printf("%04x:%04xn", FP_SEG(p), FP_OFF(p));

}