#include <iostream>

using namespace std;

#include <process.h> // для exit()

int main(int argc, char*argv[])

{

if(argc != 2)

{ cerr << "\nФормат:filename \n ";exit(-1); }

ifstream infile; // создать входной файл

infile.open(argv[1]); // и открыть его

if(!infile) // проверка наличия ошибок

{ cerr << "\nНевозможно открытие" << argv[1];exit(-1); }

infile.seekg(0, ios::end);// перейти на конец файла

// сообщить номер байта

cout << "Размер " << argv[1] << " равен "

<< infile.tellg();

cout << endl;

return 0;

}

Глава 13 Ответы на вопросы

1. а, б, в, г.

2. Директивы #include.

3. Компилятора для компилирования .cpp файла и компоновщика для свя- зывания с .OBJ файлами.

4. а, б.

5. Библиотекой класса.

6. Истинно.

7. в, г.

8. Истинно.

9. Ложно.

10. а, в, г.

11. Связывания.

12. Ложно.

13. г.

14. Областью видимости.

15. Объектными.

16. Объявлена, файле b.

17. Истинно.

18. б.

19. Ложно.

20. г.

21. б.

22. namespace.

23. б, г.

Глава 14 Ответы на вопросы

1. б и в.

2. class.

3. Ложно; различные функции создаются в процессе компиляции.

4. Правильный ответ:

template<class Т>

Т times2(T arg)

{

return arg*2;

}

5. б.

6. Истинно.

7. Реализацией.

8. в.

9. Фиксированный тип данных, произвольного типа данных.

10. Хранят данные.

11. в.

12. try, catch, throw.

13. Правильный ответ:

throw BoundsError();

14. Ложно; они должны быть частью блока повторных попыток.

15. г.

16. Правильный ответ:

class X

{

public:

int xnumber;

char xname[MAX];

X(int xd, char*xs)

{

xnumber = xd;

strcpy(xname, xs);

}

};

17. Ложно.

18. а и г.

19. г.

20. Истинно.

21. Независимый, зависимый.

22. а.

23. Ложно.

24. Дополнительную информацию.

Решения упражнений

1. Верное решение: // ex14_1.cpp

// использование шаблона для нахождения среднего от значений

// элементов массива

#include <iostream>

using namespace std;

///////////////////////////////////////////////////////////

template <class atype> // шаблон функции

atype avg(atype*array, int size)

{

atype total = 0;

for(int j = 0; j < size; j++) // среднее по массиву

total += array[j];

return (atype)total / size;

}

///////////////////////////////////////////////////////////

int intArray[] = { 1, 3, 5, 9, 11, 13 };

long longArray[] = { 1, 3, 5, 9, 11, 13 };

double double Array[] = { 1.0, 3.0, 5.0, 9.0, 11.0, 13.0 };

char charArray[] = { 1, 3, 5, 9, 11, 13 };

int main()

{

cout << "\navg(intArray)=" << avg(intArray, 6);

cout << "\navg(longArray)=" << avg(longArray, 6);

cout << "\navg(double Array)=" << avg(double Array, 6);

cout << "\navg(charArray)=" << (int)avg(charArray, 6) << endl;

return 0;

}

2. Верное решение: // ex14_2.cpp

// реализует очередь как шаблон

#include <iostream>

using namespace std;

const int MAX = 3;

///////////////////////////////////////////////////////////

template <class Type>

class Queue

{

private:

Type qu[MAX]; // массив произвольного типа

int head; // индекс начала очереди (отсюда — удаление элементов)

int tail; // индекс хвоста очереди (сюда вставлять

// новые элементы)

public:

Queue() // конструктор

{ head =-1; tail =-1; }

void put(Type var) // вставка элемента в хвост

{

qu[++tail] = var;

if(tail >= MAX - 1)// зациклить хвост

tail =-1;

}

Type get() // удаление элемента из начала

{

Type temp = qu[++head]; // сохранение элемента

if(head >= MAX - 1) // зациклить начало

head =-1;

return temp; // вернуть временное значение

}

};

///////////////////////////////////////////////////////////

int main()

{

Queue<float>q1; // q1 - объект класса Queue<float>

q1.put(1111.1F); // занести 3

q1.put(2222.2F);

q1.put(3333.3F);

cout << "1:" << q1.get() << endl; // получить 2

cout << "2:" << q1.get() << endl;

q1.put(4444.4F); // занести 2

q1.put(5555.5F);

cout << "3:" << q1.get() << endl; // получить 1

q1.put(6666.6F); // занести 1

cout << "4:" << q1.get() << endl; // получить 3

cout << "5:" << q1.get() << endl;

cout << "6:" << q1.get() << endl;

Queue<long>q2; // q2 - объект класса Queue<long>

q2.put(123123123L);// занести 3 (long), получить 2

q2.put(234234234L);

q2.put(345345345L);

cout << "1:" << q2.get() << endl;

cout << "2:" << q2.get() << endl;

cout << "3:" << q2.get() << endl;

return 0;

}

3. Верное решение:

// ex14_3.cpp

// реализует очередь в виде шаблона

// использует механизм исключений для обработки ошибок

#include <iostream>

using namespace std;

const int MAX = 3;

///////////////////////////////////////////////////////////

template <class Type>

class Queue

{

private:

Type qu[MAX]; // массив произвольного типа

int head; // индекс начала массива (т. е.,

// очереди. Отсюда будут удаляться

// старые элементы)

int tail; // индекс хвоста очереди, куда будут

// добавляться новые элементы

int count; // число элементов в очереди

public:

class full { }; // классы исключений

class empty { };

//---------------------------------------------------------

Queue() // конструктор

{ head =-1; tail =-1; count = 0; }

void put(Type var) // добавление элемента в конец

{

if(count >= MAX) // если очередь заполнена,

throw full(); // выдать исключение

qu[++tail] = var; // сохранить элемент

++count;

if(tail >= MAX - 1) // зациклить хвост

tail =-1;

}

//---------------------------------------------------------

Type get() // удаление элемента из начала

{

if(count <= 0) // если очередь пуста,

throw empty(); // выдать исключение

Type temp = qu[++head]; // получить элемент

--count;

if(head >= MAX - 1) // зациклить начало

head =-1;

return temp; // вернуть элемент

}

};

///////////////////////////////////////////////////////////

int main()

{

Queue<float>q1; // q1 - объект класса Queue<float>

float data; // элемент данных, получаемый от пользователя

char choice = 'p';// 'x', 'p' или 'g'

do // цикл (введите 'x' для выхода)

{

try // блок повторных попыток

{

cout << "\nВведите 'x' для выхода, 'p' для добавления, 'g' для выдачи:";

cin >> choice;

if(choice == 'p')

{

cout << "Введите значение:";

cin >> data;

q1.put(data);

}

if(choice == 'g')

cout << "Data =" << q1.get() << endl;

} // конец блока повторных попыток

catch(Queue<float>::full)

{

cout << "Ошибка: очередь заполнена." << endl;

}

catch(Queue<float>::empty)

{

cout << "Ошибка: очередь пуста." << endl;