Пространство имен. Раздельная компиляция

Среда, 23 Фев 2011 20:55

Краткие выводы по теории

Пространство имен — это набор определений имен, таких как определения классов и объявления переменных.

Существует три способа доступа к элементу, определенному в пространстве имен: с помощью директивы using сделать доступными программе все имена этого пространства имен; с помощью объявления using сделать доступным только одно из данных имен; при ссылке на элемент уточнить его имя именем пространства имен с помощью оператора ::.

Чтобы включить определение идентификатора в пространство имен, нужно разместить его внутри блока namespace с именем этого пространства имен.

Если отнести определяемое имя к безымянному пространству имен, оно ста­нет локальным для единицы компиляции.

Практические задания

Задание 1

Это задание позволит получить навыки в применении методов локали­зации идентификаторов, основанного на использовании пространств имен, и раздельной компиляции в той среде разработки приложений, которой вы пользуетесь. Создайте файл f.h и поместите в него объявление функции

1
void f()

отнесенное к пространству имен А. Затем создайте файл g.h и поместите в него объявление функции

1
void g()

отнеся его к тому же пространству имен А.

Определения этих функций поместите в файлы f.cpp и g.срр соответственно. Данные определения тоже отнесите к пространству имен А. Код функций можете сделать любым, но включите в него операторы, подобные следующему:

1
<strong>cout « "имя_функции " « end</strong><strong>l;</strong>

где имя_функции — имя выполняющейся в данный момент функции.

Для функции main создайте файл main.cpp, куда с помощью директив #include включите минимальный набор файлов, необходимый для доступа к функциям из пространства имен А. Из функции main вызовите функцию f, а затем д. Откомпилируйте, скомпонуйте и запустите программу.

Для доступа к элементам из пространств имен можете использовать локаль­ные объявления using, такие как

1
using std::cout;

или локальные директивы, например:

1
using namespace std;

входящие в состав блока, либо уточнять имена этих элементов именем про­странства имен: std::cout.

He используйте только глобальные директивы using, относящиеся ко всему файлу. Разумеется, помимо доступности элементов из пространства имен std (таких, как cout) нужно будет обеспечить доступ к функциям из пространства имен А.

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

Задание 2

Изучите определение класса PFArrayD, предназначенного для работы с частично заполненным массивом значений типа double.

//определение класса с динамическим массивом-элеменгтом

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
class PFArrayD

{

public:

PFArrayD();

PFArrayD(int capacityValue);

PFArrayD(const PFArrayD&amp; pfaObject);

<strong>void addElement(double element);</strong>

//предусловие: массив неполон.

//постусловие: параметр element добавлен в массив.

bool <strong>full( )</strong> const { return (capacity == used); }

//возвращает значение true, если массив полон, иначе false

<strong>int getCapacity( ) const { return capacity; }</strong>

<strong>int getNumberUsed( ) const { return used; }</strong>

<strong>void emptyArray( ){</strong> used = 0; }

//очищает массив.

double<strong>&amp; operator[](</strong>int index);

//оператор доступа к элементам массива (0…numberUsed-1

PFArrayD&amp; operator =(const PFArrayD&amp; rightSide);

~PFArrayD( );

private:

double *a; //массив значений типа  double.

int capacity; //размер массива.

int used; //количество заполненных элементов.

};

________________________________________

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
//Определенгие функций-элементов класса.

<strong>PFArrayD::PFArrayD( ) :capacity(50), used(0)</strong>

{

a = new double[capacity];

}

PFArrayD::PFArrayD(int size) :capacity(size), used(0)

{

a = new double[capacity];

}

PFArrayD::PFArrayD(const PFArrayD&amp; pfaObject)

:capacity(pfaObject.getCapacity( )), used(pfaObject.getNumberUsed( ))

{

a = new double[capacity];

for (int i =0; i &lt; used; i++)

a[i] = pfaObject.a[i];

}

void PFArrayD::addElement(double element)

{

if (used &gt;= capacity)

{

cout &lt;&lt; "Попытка выйти за пределы PFArrayD.\n";

exit(0);

}

a[used] = element;

used++;

}

<strong>double&amp; PFArrayD::operator[](int index)</strong>

{

if (index &gt;= used)

{

cout &lt;&lt; "Illegal index in PFArrayD.\n";

exit(0);

}

return a[index];

}

PFArrayD&amp; PFArrayD::operator =(const PFArrayD&amp; rightSide)

{

if (capacity != rightSide.capacity)

{

delete [] a;

a = new double[rightSide.capacity];

}

capacity = rightSide.capacity;

used = rightSide.used;

for (int i = 0; i &lt; used; i++)

a[i] = rightSide.a[i];

return *this;

}

PFArrayD::~PFArrayD( )

{

delete [] a;

}

_________________________________________

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
//Демонстрационнная программа для класса PFArrayD

#include &lt;iostream&gt;

#include "pfarrayd.h"

using std::cin;

using std::cout;

using std::endl;

void testPFArrayD( );

//тест для класса  PFArrayD.

int main( )

{

cout &lt;&lt; "Эта программа тестирует класс PFArrayD.\n";

char ans;

do

{

testPFArrayD( );

cout &lt;&lt; "Еще раз? (y/n) ";

cin &gt;&gt; ans;

}while ((ans == 'y') || (ans == 'Y'));

return 0;

}

void testPFArrayD( )

{

int cap;

cout &lt;&lt; "введите размер массива ";

cin &gt;&gt; cap;

PFArrayD temp(cap);

cout &lt;&lt; "введите до  " &lt;&lt; cap &lt;&lt; " неотрицательных цифр.\n";

cout &lt;&lt; "Поместите отрицательное число в конце .\n";

double next;

cin &gt;&gt; next;

while ((next &gt;= 0) &amp;&amp; (!temp.full( )))

{

temp.addElement(next);

cin &gt;&gt; next;

}

cout &lt;&lt; "вы ввели следующее "

&lt;&lt; temp.getNumberUsed( ) &lt;&lt; " чисел:\n";

int index;

int count = temp.getNumberUsed( );

for (index = 0; index &lt; count; index++)

cout &lt;&lt; temp[index] &lt;&lt; " ";

cout &lt;&lt; endl;

cout &lt;&lt; "(plus a sentinel value.)\n";

}

Модифицируйте эту программу так, чтобы в ней использовались пространства имен, а ее базовые части компилировались раздельно: поместите определение класса и объяв­ления функций в один файл, определение этих функций — в другой, а демон­страционную программу — в третий. Распределите части пространства имен между несколькими файлами.

Для доступа к элементам из пространств имен можете использовать локаль­ные объявления using, такие как

1
using std::cout;

или локальные директивы, например:

1
using namespace std:

входящие в состав блока, либо уточнять имена этих элементов именем про­странства имен, вот так: std:: cout. He используйте только глобальные дирек­тивы using, относящиеся ко всему файлу.

Задание 3

Изучите программный код двумерного динамического массива

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
#include &lt;iostream&gt;

using std::cout;

using std::cin;

using std::endl;

typedef int* IntArrayPtr;

int main( )

{

int d1,d2;

cout&lt;&lt;”Введите количество строк и столбцов\n”;

cin&gt;&gt;d1&gt;&gt;d2;

IntArrayPtr *m=new IntArrayPtr[d1];

int I,j;

for (i=0;i&lt;d1;i++)

{m[i]=new int[d2];

cout&lt;&lt;”Введите”&lt;&lt;d1&lt;&lt;” строк из“&lt;&lt;d2&lt;&lt; “столбцов целых чисел\n”;

for (i=0;i&lt;d1;i++)

for (j=0;i&lt;d2;j++)

cin&gt;&gt;m[i][j];

cout&gt;&gt;”Вывод массива\n”;

for (i=0;i&lt;d1;i++)

{

for (j=0;i&lt;d2;j++)

cot&lt;&lt;m[i][j]&lt;&lt;”   “;

cout&lt;&lt;endl;

}

for (i=0;i&lt;d1;i++)

delete[] m[i];

delete[] m;

}

Напишите определение класса TwoD, объект которого представляет двухмерный массив типа double. В классе TwoD должны содержаться закрытая переменная-элемент типа указатель на double, которая будет содержать адрес динамического массива, и две переменные-элементы типа int (или  unsigned int) MaxRows и MaxCols, содержащие количество строки столбцов массива.

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

Перегрузите оператор + как дружественную функцию класса, чтобы он складывал элементы двух двухмерных массивов. Эта функция должна возвращать объект типа TwoD, элемент которого с индексами i и j являлся бы  суммой элементов первого и второго операнда с теми же индексами.

Напишите конструктор копии, перегруженный оператор =  и деструктор.

Функции-элементы класса, не изменяющие данные объектов, объявите как const.

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

Для доступа к элементам из пространств имен можете использовать локаль­ные объявления using, такие как

1
using std::cout;

или локальные директивы, например:

1
using namespace std;

входящие в состав блока, либо уточнять имена этих элементов именем про­странства имен: std::cout. He используйте только глобальные директивы using, относящиеся ко всему файлу.



Вы можете оставить отзыв или трекбек со своего сайта.

Ваш отзыв