Объявление переменной
Объявление переменной в C++ происходит таким образом: сначала указывается тип данных для этой переменной, а затем название этой переменной.
Пример объявления переменных
int a; // объявление переменной a целого типа.
float b; // объявление переменной b типа данных с плавающей запятой.
double c = 14.2; // инициализация переменной типа double.
char d = 's'; // инициализация переменной типа char.
bool k = true; // инициализация логической переменной k.
2. Раскройте понятия: коллекции общего назначения, основные элементы класса Queue. Приведите примеры.
1) коллекции общего назначения (Не совсем уверен, что правильно, но это единственное что удалость найти)
Коллекция в программировании — программный объект, содержащий в себе, тем или иным образом, набор значений одного или различных типов, и позволяющий обращаться к этим значениям. Коллекция позволяет записывать в себя значения и извлекать их. Назначение коллекции — служить хранилищем объектов и обеспечивать доступ к ним.
Основное достоинство коллекций состоит в том, что они стандартизируют способ обработки групп объектов в прикладных программах. Все коллекции разработаны на основе набора четко определенных интерфейсов. Ряд встроенных реализаций таких интерфейсов, как ArrayList, Hashtable, Stack и Queue, вы можете использовать "как есть". У каждого программиста также есть возможность реализовать собственную коллекцию, но в большинстве случаев достаточно.
Коллекции общего назначения
Классы коллекций общего назначения:
| Класс | Описание |
| · Stack | Стек - частный случай однонаправленного списка, действующий по принципу: последним пришел - первым вышел |
| · Queue | Очередь - частный случай однонаправленного списка, действующего по принципу:первым пришел - первым вышел |
| · ArrayList | Динамический массив, т.е. массив который при необходимости может увеличивать свой размер |
| · Hashtable | Хеш-таблица для пар ключ/значение |
| · SortedList | Отсортированный список пар ключ/значение |
Пример коллекции общего назначения будет являться класс Queue который представлен ниже
2) основные элементы класса Queue:
Очередь – это динамическая структура данных которая состоит из набора элементов которые размещены последовательно друг за другом. При этом добавление элементов осуществляется с одной стороны, а удаление (вытягивание) – с другой стороны.
Очередь построена по принципу LILO (last in — last out: последним пришел — последним вышел).
Пример очереди:
· очередь в магазине;
· очередь документов на печать на принтере;
Виды очередей
Различают следующие виды очередей:
· простая очередь;
· кольцевая очередь. В такой очереди элемент, который выходит с начала очереди, будет помещен в ее конец;
· очередь с приоритетами. В такой очереди элементы размещаются по их приоритетам (весовым коэффициентам). Первым из очереди выходит элемент с наивысшим приоритетом.
Любой вид очереди может иметь ограничение по размеру (количество элементов в очереди).
Способы реализации очереди
В программе очередь можно реализовывать в виде:
· статического массива с ограничением на размер в очереди;
· динамического массива;
· односвязного списка;
двусвязного списка.
В примере объявляется шаблонный класс Queue, реализующий очередь в виде динамического массива для некоторого обобщенного типа T.
В классе реализованы следующие поля и методы:
· целочисленная внутренняя переменная count – количество элементов в очереди;
· внутренняя переменная p – указатель на тип T. Этот указатель есть массивом данных образующих очередь. Элемент массива с индексом 0 есть началом очереди. Элемент с индексом count-1 есть конец очереди;
· конструктор по умолчанию;
· конструктор копирования Queue(const Queue&);
· оператор копирования operator=(const Queue&);
· метод push() – добавляет элемент в конец очереди;
· деструктор;
· метод pop() – вытягивает первый элемент из очереди;
· метод GetItem() – читает первый элемент из очереди не вытягивая его;
· метод clear() – очищает очередь;
· метод IsEmpty() – проверяет пустая ли очередь;
· метод Get() – возвращает количество элементов в очереди;
· метод print() – выводит очередь на экран.
#include <iostream>
#include <new>
using namespace std;
// Динамическая структура данных "очередь"
template <typename T>
class Queue
{
private:
T* p; // динамический массив
int count; // количество элементов в очереди
public:
// конструктор по умолчанию
Queue()
{
count = 0; // очередь пустая
}
// конструктор копирования
Queue(const Queue& obj)
{
// скопировать obj в текущий объект
count = obj.count;
try {
// попытка выделить память для p
p = new T[count];
// заполнить значениями
for (int i = 0; i < count; i++)
p[i] = obj.p[i];
}
catch (bad_alloc e)
{
// если память не выделена, то вывести текст ошибки
cout << e.what() << endl;
count = 0; // создать пустую очередь
}
}
// добавить элемент в очередь
void push(T item)
{
T* p2; // объявить дополнительный указатель
p2 = p; // перенаправить дополнительный указатель на p
try {
// попытка выделить новый фрагмент памяти для p, но на 1 больше
p = new T[count + 1];
// скопировать данные из участка на который указывает p2 (старые данные)
// в участок, на который указывает p
for (int i = 0; i < count; i++)
p[i] = p2[i];
// скопировать последний элемент
p[count] = item;
// увеличить количество элементов на 1
count++;
// освободить предварительно выделенную память
if (count > 1)
delete[] p2;
}
catch (bad_alloc e)
{
// если память не выделена
cout << e.what() << endl; // вывести сообщение об ошибке
// вернуть старый указатель на p
p = p2;
}
}
// вытянуть первый элемент из очереди
T pop()
{
if (count == 0)
return 0;
// заполнить элемент, который вытягивается из очереди
T item;
item = p[0];
// сформировать новый участок памяти, который на 1 меньше
try {
T* p2;
// попытка выделить пам'ять
p2 = new T[count - 1];
count--; // уменьшить количество элементов в очереди
// p=>p2
for (int i = 0; i < count; i++)
p2[i] = p[i + 1]; // копируются все кроме первого элемента
// освободить участок, на который указывает p
if (count > 0)
delete[] p;
// перенаправить p на p2
p = p2;
// вернуть item
return item;
}
catch (bad_alloc e)
{
// если память не выделилась, то вернуть 0
cout << e.what() << endl;
return 0;
}
}
// операторная функция operator=(),
// реализует присваивание объектов типа Queue
Queue& operator=(const Queue& obj)
{
T* p2; // указатель на дополнительную память
try {
// попытка выделить новый участок памяти для p2
p2 = new T[obj.count];
// если память выделена успешно,
// можно освобождать предварительно выделенную память для p
if (count > 0)
delete[] p;
// скопировать obj в текущий объект
p = p2; // перенаправить p на p2
count = obj.count;
// заполнить значениями
for (int i = 0; i < count; i++)
p[i] = obj.p[i];
}
catch (bad_alloc e)
{
// если память не выделилась, то вывести соответствующее сообщение
cout << e.what() << endl;
}
return *this; // вернуть текущий объект
}
// деструктор
~Queue()
{
if (count > 0)
delete[] p;
}
// взять первый элемент из очереди не вытягивая его
T GetItem()
{
if (count > 0)
return p[0];
else
return 0;
}
// очистка очереди
void clear()
{
if (count > 0)
{
delete[] p;
count = 0;
}
}
// проверка существования элементов в очереди
bool IsEmpty()
{
return count == 0;
}
// количество элементов в очереди
int GetN()
{
return count;
}
// метод, выводящий очередь
void print(const char* objName)
{
cout << "Object: " << objName << endl;
for (int i = 0; i < count; i++)
cout << p[i] << "\t";
cout << endl;
cout << "---------------------" << endl;
}
};
void main()
{
Queue<int> Q1;
Q1.print("Q1");
Q1.push(5);
Q1.print("Q1");
Q1.push(8);
Q1.push(11);
Q1.push(17); // Q1 = {5,8,11,17}
Q1.print("Q1");
int d;
d = Q1.GetItem();
cout << "d = " << d << endl;
Q1.print("Q1");
Queue<int> Q2 = Q1;
Q2.print("Q2");
Queue<int> Q3;
Q3 = Q1 = Q2;
Q1.push(333);
Q2.push(555);
Q1.print("Q1");
Q2.print("Q2");
Q3.print("Q3");
Q2.clear();
if (Q2.IsEmpty())
cout << "OK" << endl;
else
cout << "NO" << endl;
cout << "n = " << Q3.GetN() << endl;
}
Задача (билет 2)
1.Составить программу для расчета заданных выражений. Вводить исходные данные с клавиатуры. Обязательно проверять исключительные ситуации. Значение p = 3,1415926.
#include<stdio.h>
#include<iostream>
#include<conio.h>
#include<math.h>
using namespace std;
void main()
{
setlocale(LC_ALL, "rus");
int x,y,z;
double pi= 3.1415926;
double e = 2.72;
double h;
cout << "Введите х" << endl;
cin >> x;
cout << "Введите y" << endl;
cin >> y;
cout << "Введите z" << endl;
cin >> z;
h = ((pow(x, y + 1) + pow(e, y - 1)) / (1 + x * fabs(y - tan(z)))) * (1 + fabs(y - x)) + ((pow(fabs(y - x), 2)) / (2)) - ((pow(fabs(y - x), 3)) / (3));
cout << h << endl;
system("pause");
}