Реализовать двусвязный список

#include <iostream>
 
#include <stdio.h>
 
#include <locale.h>
 
using namespace std;
 
struct Photo {
 
public:
 
char* ID_Photo; //Модель фотоаппарата.
 
int Frame; //Количество кадров в заряженной пленке.
 
int Number_Frame; //Номер текущего кадра.
 
void Frame_New(); //зарядить в фотоаппарат новую пленку с заданным количеством кадров.
 
void Single_shooting(); //Покадровая съемка.
 
void Removing_the_film();//Извлечь пленку.
 
void Printf_information_Photo();//Вывод информации.
 
};
 
template<typename T>
 
class List {//создание узла
 
public:
 
List();
 
~List();
 
void push_back(T data);//добавление в конец списка
 
void addFirst(T data);//добавление в начало списка
 
void addNext(T data);//добавление после заданного
 
void addPref(T data);//добавление узла перед заданным
 
void Del();//удаление узла
 
void poisk(T data);//поиск по списку
 
int GetSize() { return Size; }//количество узлов
 
void dob(T data);
 
private://создание списка
 
template<typename T>
 
class Node {
 
public:
 
Node* pNext;//указатель на следующий узел
 
Node* prev;//указатель на предыдущий узел
 
T data;
 
Node(T data = T(), Node* pNext = nullptr, Node* prev = nullptr) {
 
this->data = data;
 
this->pNext = pNext;
 
this->prev = prev;
 
}
 
};
 
int Size;
 
Node<T>* Head;//указатель на голову списка
 
Node<T>* Tail;//указатель на хвост списка
 
};
 
template<typename T>
 
List<T>::List() {
 
Size = 0;
 
Head = nullptr;
 
}
 
template<typename T>
 
List<T>::~List() {
 
}
 
template<typename T>//добавление узла в начало списка
 
void List<T>::addFirst(T data)
 
{
 
Head = new Node<T>(data, Head);//добавляем узел в начало списка
 
Size++;
 
}
 
template<typename T>
 
void List<T>::addNext(T data)//добавление после заданного
 
{
 
if (Head == 0) {//если в голове ничего нет , то добавляем на него новый узел
 
Head = new Node<T>(data);
 
}
 
else {
 
if (Tail == nullptr) {//если в хвосте ничего нет, добавляем в него узел
 
Tail = new Node<T>(data);
 
}
 
else {
 
Node<T>* current = this->Head;//указатель на голову
 
current = new Node<T>(data);//создаем новый узел в голове
 
current->pNext = Head->pNext;
 
Head->pNext = current;
 
}
 
}
 
}
 
template<typename T>
 
void List<T>::addPref(T data)//добавляем узел перед головой
 
{
 
Node<T>* current=new Node<T>(data);//на куррент создается новый узел
 
Node<T>* p=this->Head;//p указывает на голову списка
 
while (p && p->pNext != Tail) p = p->pNext;//проверка
 
if (p) {
 
current = new Node<T>(data);//создаем новый узел
 
current->pNext = Head->pNext;//добавляем перед головой
 
Head->pNext = current;//старую голову делаем курент
 
};
 
}
 
template<typename T>//удаление головый спика
 
void List<T>::Del()
 
{
 
Node<T>* temp = Head;//указатель на голову
 
Head = Head->pNext;//переходим на следующий узел после головы
 
delete temp;//удаляем темп
 
Size--;
 
}
 
template<typename T>
 
void List<T>::poisk(T data)
 
{
 
char p[256]; //строка в которой хранится искомый ф.а
 
printf("введите название фотоаппарата которое ищите: ");
 
cin >> p;//считываем искомый ф.а
 
Node<T>* current = this->Head;//указатель на голову через current
 
while (strcmp(current->data->ID_Photo, p) != 0) {
 
cout << current->data->ID_Photo << ' ' << p << endl;
 
current = current->pNext;
 
}
 
cout << current->data->ID_Photo << endl;//выводим из списка все ID_Photo
 
}
 
template<typename T>//вывод на экран значений узлов
 
void List<T>::dob(T data)
 
{
 
Node<T>* current = this->Head;//указатель на голову списка
 
while (current != NULL)
 
{
 
cout << current->data->ID_Photo << endl;//вывод на экран ID_Photo
 
current = current->pNext;
 
}
 
}
 
template<typename T>//добавление узла в конец списка
 
void List<T>::push_back(T data)
 
{
 
if (Head == nullptr) {//проверяем на наличие узла в начале спика, если он пустой то добавляем узел
 
Head = new Node<T>(data);
 
}
 
else {
 
Node<T>* current = this->Head;//добавляем промежуточную переменную
 
while (current->pNext != nullptr)//пока current не ноль, идем дальше
 
{
 
current = current->pNext;
 
}
 
Tail = current->pNext = new Node<T>(data);//как только нужное условие выполнилось, создаем узел
 
}
 
Size++;
 
}
 
int Frame_New(Photo* a)
 
{ //заряжаем новую пленку
 
a->Number_Frame = 0;
 
std::cout << "Пленка извлечена.\n";
 
std::cout << "Введите количество кадров: ";
 
std::cin >> a->Frame;
 
return 0;
 
}
 
void Single_shooting(Photo* a)
 
{ //покадровая съемка
 
int i;
 
for (i = 0; i < a->Frame; i++)
 
{
 
std::cout << "\nНомер кадра:" << a->Number_Frame;
 
a->Number_Frame++;
 
}
 
getchar;
 
}
 
void Removing_the_film(Photo* a)
 
{ //извлечь пленку
 
a->Frame = 0;
 
a->Number_Frame = 0;
 
std::cout << "\nПленка извлеченаб количество кадров 0.";
 
getchar;
 
}
 
void Printf_information_Photo(Photo* a)
 
{ //вывод информации
 
printf("\nКоличество кадров:%d", a->Frame);
 
printf("\nНомер кадра:%d", a->Number_Frame);
 
getchar;
 
}
 
int main()
 
{
 
setlocale(LC_ALL, "Russian");
 
///////////////////////////////////////////////////работа с узлами
 
List<Photo*> lst;
 
string name;
 
/// ////////////////////////////////////////////////////<summary>
 
Photo* a;//указатели на новые ф.а
 
Photo* b;
 
Photo* c;
 
a = new Photo;
 
b = new Photo;
 
c = new Photo;
 
a->ID_Photo = new char[256]; //название фотоаппарата
 
b->ID_Photo = new char[256];
 
c->ID_Photo = new char[256];
 
std::cout << "Введите название фотоаппарата: ";
 
std::cin.getline(a->ID_Photo, 256); //вводим название фотоаппарата
 
std::cout << "Введите количество кадров в пленке: ";
 
std::cin >> a->Frame; //вводим количество кадров в пленке
 
a->Number_Frame = 1; //кадр переходит на первый
 
int flag = 0;
 
std::cin.getline(b->ID_Photo, 256);
 
lst.addFirst(b);
 
lst.push_back(a);
 
std::cin.getline(c->ID_Photo, 256);
 
lst.addNext(c);
 
while (flag != 5)
 
{
 
std::cout << "\nВведите 1, чтобы зарядить в фотоаппарат новую пленку.";
 
std::cout << "\nВведите 2, чтобы сделать покадровую съемку.";
 
std::cout << "\nВведите 3, чтобы извлечь пленку.";
 
std::cout << "\nВведите 4, чтобы вывести информацию о состоянии фотоаппарата.";
 
cout << "\nВведите 6, что бы добавить узел в начало списка";
 
cout << "\nВведите 7, чтобы добавить узел в конец спичка";
 
cout << "\nВведите 8, чтобы добавить узел после заданного";
 
cout << "\nВведите 9, чтобы добавить узел перед заданным";
 
cout << "\nВведите 10, чтобы удалить голову списка";
 
cout << "\nВвидите 11, чтобы вывести количество узлов на экран";
 
cout << "\nВведите 12, чтобы вывести элементы списка";
 
cout << "\nВведите 13, чтобы сделать поиск по списку";
 
std::cin >> flag; //считываем нужную операцию
 
switch (flag) { //выполняем нужную уперацию
 
case 1: Frame_New(a); break;
 
case 2: Single_shooting(a); break;
 
case 3: Removing_the_film(a); break;
 
case 4: Printf_information_Photo(a); break;
 
case 6: lst.addFirst(a); break;
 
case 7: lst.push_back(a); break;
 
case 8: lst.addNext(a); break;
 
case 9: lst.addPref(a); break;
 
case 10: lst.Del(); break;
 
case 11: cout << lst.GetSize() << endl; break;
 
case 12: lst.dob(a); break;
 
case 13: lst.poisk(a); break;
 
}
 
}
 
}

#include <iostream>
#include <math.h>
 
using namespace std;
 
struct MyStruct
{
 
    double O1, O2; //центр эллипса
    double os1, os2; //малая/большая полуось
};
 
MyStruct ellipse(double O1, double O2, double os1, double os2) { 
    MyStruct S;
    S.O1 = 0;
    S.O2 = 0;
    S.os1 = 2;
    S.os2 = 4;
    return S;
}
 
void os1(MyStruct* T, double newos1) //изменение первой полуоси
{   
    T->os1 = newos1;
}
void os2(MyStruct* K, double newos2) //изменение второй полуоси
{
    K->os2 = newos2;
}
void O1 (MyStruct* center, double newcenter1) //изменение центра
{
    center->O1 = newcenter1; 
    
}
void O2(MyStruct* center, double newcenter2)
{
    center->O2 = newcenter2;
}
 
double area(MyStruct* A) //площадь
{   
    double PI = 3.14159265358979323846;
    double Area = A->os1 * A->os2 * PI ;
    return Area;
}
    
void Focus(MyStruct* F,double* f1,double* f2) //фокус
{
    double c;
    if (F->os1 > F->os2) {
        c = sqrt(F->os1 * F->os1 - F->os2 * F->os2);
        f1[0] = -c;
        f1[1] = 0;
        f2[0] = c;
        f2[1] = 0;
    }
    else
    {
        c = sqrt(F->os2 * F->os2 - F->os1 * F->os1);
        f1[0] = 0;
        f1[1] = -c;
        f2[0] = 0;
        f2[1] = c;
    }
    if (F->O1 != 0 || F->O2 != 0) // если эллипс находится не в начале координат
    {
        if (F->os1 > F->os2)
        {
            
            f1[0] = f1[0] + F->O1;
            f2[0] = f2[0] + F->O2;
        }
        else 
        {
            f1[1] = f1[1] + F->O1;
            f2[1] = f2[1] + F->O2;
        }
    }
    
}
 
 
 
int main()
{
    setlocale(LC_ALL, "Russian");
    MyStruct a;
    double v;
    cout << "Введите,плиииииз,первую полуось: ";
    cin >> v;
    
    os1(&a, v);
    std::cout << "Первая полуось: " << a.os1 << endl;
 
    cout << "Введите,плиииииз,вторую полуось: ";
    cin >> v;
    os2(&a, v);
    
    std::cout << "Вторая полуось: " << a.os2 << endl;
 
    cout << "Введите,плиииииз,координату центра по Х: ";
    cin >> v;
    O1(&a, v);
    
    std::cout << "Центр1: " << a.O1 << endl;
 
    cout << "Введите,плиииииз,координату центра по Y: ";
    cin >> v;
    O2(&a, v);
    
    std::cout << "Центр2: " << a.O2 << endl;
 
    std::cout << "Площадь: " << area(&a) << endl;
    double* f1 = new double[2];
    double* f2 = new double[2];
    Focus(&a, f1, f2);
    std::cout << "F1: " << "(" << f1[0] << ";" << f1[1] << ")" << endl;
    std::cout << "F2: " << "(" << f2[0]  << ";" << f2[1] << ")" << endl;
    
}