Нахождения перимтров нескольких трапеций заданных по точкам

#include "StdAfx.h"
 #include <math.h>
#include <iostream>
using namespace std;
 
int main()
{
   
    double P,M,M1,M2,M3,x1,y1,x2,y2,x3,y3,x4,y4;
    cout<<"Введите координаты трапеции"<<endl;
    cout <<"A(x,y):";
    cin >> x1 >> y1;
    cout<<endl;
    cout <<"B(x,y):";
    cin >> x2 >> y2;
    cout<<endl;
    cout <<"C(x,y):";
    cin >> x3 >> y3;
    cout<<endl;
    cout <<"D(x,y):" ;
    cin >> x4 >> y4;
    cout<<endl;
    M= sqrt((x2-x1)*(x2-x1)+(y2-y1)*(y2-y1));
    M1= sqrt((x3-x2)*(x3-x2)+ (y3-y2)*(y3-y2));
    M2= sqrt((x4-x3)*(x4-x3)+ (y4-y3)*(y4-y3));
    M3= sqrt((x1-x4)*(x1-x4)+ (y1-y4)*(y1-y4));
    P=M1+M2+M3+M;
    cout<<"Периметр="<<P<<endl;
}

Макс
// ConsoleApplication1.cpp: определяет точку входа для консольного приложения.
//
 
#include "stdafx.h"
#include <iostream>
#include <stdlib.h>
#include <time.h>
 
using namespace std;
 
const int n = 5;
 
typedef struct{
float x, y;
} POINT;
 
typedef struct{
POINT p[4];
} POINTARRAY;
 
int _tmain(int argc)
{
 
 
srand(time(0));
POINTARRAY arr[n];
 
for(int i = 0; i<n;i++)
{
for(int j = 0; j<4; j++)
{
arr[i].p[j].x = rand();
arr[i].p[j].y = rand();
}
 
}
 
 
float per[n] = {0};
 
for(int i = 0; i<n;i++)
{
int otr[4] = {0};
otr[0] = sqrt(pow((arr[i].p[0].x-arr[i].p[1].x),2)+pow((arr[i].p[0].y-arr[i].p[1].y),2));
otr[1] = sqrt(pow((arr[i].p[1].x-arr[i].p[2].x),2)+pow((arr[i].p[1].y-arr[i].p[2].y),2));
otr[2] = sqrt(pow((arr[i].p[2].x-arr[i].p[3].x),2)+pow((arr[i].p[2].y-arr[i].p[3].y),2));
otr[3] = sqrt(pow((arr[i].p[3].x-arr[i].p[0].x),2)+pow((arr[i].p[3].y-arr[i].p[0].y),2));
for(int j =0; j<=3;j++)
{
per[i]+=otr[j];
}
 
}
 
for(int i = 0; i<n;i++)
{
for(int j =0; j<4; j++)
{
printf("%f %f \n\t", arr[i].p[j].x, arr[i].p[j].y);
}
printf("perimetr %f \n\n\t", per[i]);
}
 
for (int i = 0; i < n; i++)
for (int j = i+1; j < n; j++)
if (per[i] < per[j])
{
int buf = per[i];
per[i] = per[j];
per[j] = buf;
 
POINTARRAY bufPoint= arr[i];
arr[i] = arr[j];
arr[j] = bufPoint;
 
}
 
printf("\n sorting \n");
 
for(int i = 0; i<n;i++)
{
for(int j =0; j<4; j++)
{
printf("%f %f \n\t", arr[i].p[j].x, arr[i].p[j].y);
}
printf("perimetr %f \n\n\t", per[i]);
}
 
getchar();
return 0;
}

// Trapecia.cpp: определяет точку входа для консольного приложения.
//
 
//На вход подается некоторое количество трапеций (координаты вершин). 
//Отсортировать и вывести их по возрастанию периметров.  
 
#include "stdafx.h"
#include <iostream>
#include <stdlib.h>
#include <time.h>
 
using namespace std;
const int n = 2;
 
class tochka
{
public:
    void vvod()
    {
      int x,y;
     cout << "Vvedite kkoardinati x=";
     cin >>x;
     cout << "Vvedite kkoardinati y=";
     cin >>y;
    }
}; 
class Perimetr
{
public:
    void perimetr()
    {
      int x,y;
     cout << "Vvedite kkoardinati x=";
     cin >>x;
     cout << "Vvedite kkoardinati y=";
     cin >>y;
    }
}; 
typedef struct{
    int x,y;
}
POINT;
typedef struct{
    POINT p[4];
}
POINTARRAY;
 
int main(int argc)
{
 srand (time(0));
POINTARRAY arr[n];
 for(int i=0;i<n;i++)
 {
      for(int j=0;i<4;i++)
      {
    tochka x;
    x.vvod();
    tochka y;
    y.vvod();
      }
 }
 float per[n] = {0};
 
for(int i = 0; i<n;i++)
{
int otr[4] = {0};
otr[0] = sqrt(pow((arr[i].p[0].x-arr[i].p[1].x),2)+pow((arr[i].p[0].y-arr[i].p[1].y),2));
otr[1] = sqrt(pow((arr[i].p[1].x-arr[i].p[2].x),2)+pow((arr[i].p[1].y-arr[i].p[2].y),2));
otr[2] = sqrt(pow((arr[i].p[2].x-arr[i].p[3].x),2)+pow((arr[i].p[2].y-arr[i].p[3].y),2));
otr[3] = sqrt(pow((arr[i].p[3].x-arr[i].p[0].x),2)+pow((arr[i].p[3].y-arr[i].p[0].y),2));
for(int j =0; j<=3;j++)
{
per[i]+=otr[j];
}
 
}
 
//for(int i = 0; i<n;i++)
//{
//for(int j =0; j<4; j++)
//{
//printf("%f %f \n\t", arr[i].p[j].x, arr[i].p[j].y);
//}
//printf("perimetr %f \n\n\t", per[i]);
//}
 
for (int i = 0; i < n; i++)
for (int j = i+1; j < n; j++)
if (per[i] < per[j])
{
int buf = per[i];
per[i] = per[j];
per[j] = buf;
 
POINTARRAY bufPoint= arr[i];
arr[i] = arr[j];
arr[j] = bufPoint;
 
}
 
printf("\n sorting \n");
 
for(int i = 0; i<n;i++)
{
for(int j =0; j<4; j++)
{
printf("%f %f \n\t", arr[i].p[j].x, arr[i].p[j].y);
}
printf("perimetr %f \n\n\t", per[i]);
}
 
getchar();
return 0;
}

class tochka {
 public:
  int x, y; 
  void vvod() {
    cout << "Vvedite kkoardinati x="; cin >>x; 
    cout << "Vvedite kkoardinati y="; cin >>y;
  } 
};

class Trap
{
public:
    Trap();
    ~Trap();
    void tochka();
    int Perimetr();
private:
 
};
 
Trap::Trap()
{
}
 
Trap::~Trap()
{
}

#include "stdafx.h"
#include "math.h"
#include <iostream>
using namespace std;
 
 
class pset 
{   
public:
     float x,y,c;
     void input ()
     { cout<<"input x";
       cin>>x;
       cout<<"input y";
       cin>>y;
     
     }
 
 
    void output()
     {
         cout << "(" << x << ";" << y << ";" << ")";
     }
 
     float getx() 
       {return x;}
     float gety() 
       {return y;}
    
 
 
     };
 
 
class Trap
{
private:
    pset A,B,C,D,S;
public:
    void input ()
{ cout << "input vektora:\n";
        A.input();
        B.input();
        C.input();
        D.input();
        
}
 
void output ()
{ 
    A.output();
    B.output();
    C.output();
    D.output();
    cout<<"\n";
}
    
    float volume ()                // ф-я подсчета объема
    {   
        float  AS,BS,CS,DS,Z;
 
        AS= sqrt((B.x-A.x)*(B.x-A.x) + (B.y-A.y)*(B.y-A.y)); 
        
        BS =sqrt((C.x-B.x)*(C.x-B.x) + (C.y-B.y)*(C.y-B.y)); 
        
        CS =sqrt((D.x-C.x)*(D.x-C.x) + (D.y-C.y)*(D.y-C.y)); 
 
         DS =sqrt((A.x-D.x)*(A.x-D.x) + (A.y-D.y)*(A.y-D.y)); 
 
         return  AS+DS+CS+BS;
            }
};
 
 
void main()
{
    
    Trap *P;
    int n, mv;
    float maxV = 0; // максимальный объем
    Trap *maxP;
    cout << "Input N = \n" ;
    cin >> n;
    P = new Trap[n];
 
    for (int i=0; i<n; i++)
    {       P[i].input();
    }
    
    maxV=0;
    maxP=NULL;
    mv=0;
    for (int i=0;i<n;i++)
    {
       if (maxV <(*(P+i)).volume())
      { maxV=(*(P+i)).volume();
        maxP=(P+i);
        mv=i;
      }
    }
 
 cout<<"max Trap = "; maxP->output();
 cout << "\n";
 cout<<"max Volume = "<<maxV << endl;
 
}

#include <iostream>
#include <algorithm>
#include <iterator>
#include <vector>
 
class Trapeze
{
    public:
        Trapeze(){}
        Trapeze(double x1, double y1, double x2, double y2,
                double x3, double y3, double x4, double y4);
        friend bool operator< (const Trapeze &, const Trapeze &);
        friend std::ostream& operator<< (std::ostream &, const Trapeze &);
    private:
        double _x1, _y1, _x2, _y2, _x3, _y3, _x4, _y4, P;
};
 
int main()
{
    double x1, x2, x3, x4, y1, y2, y3, y4;
    std::vector<Trapeze> v;
    while(std::cin>> x1>> y1>> x2>> y2>> x3>> y3>> x4>> y4)
        v.push_back (Trapeze (x1, y1, x2, y2, x3, y3, x4, y4) );
    std::sort(v.begin(), v.end());
    std::copy(v.begin(), v.end(),
        std::ostream_iterator<Trapeze> (std::cout, "\n") );
    return 0;
}
 
Trapeze::Trapeze(double x1, double y1, double x2, double y2,
                 double x3, double y3, double x4, double y4): _x1(x1), _y1(y1),
                _x2(x2), _y2(y2), _x3(x3), _y3(y3), _x4(x4), _y4(y4)
{
    P = sqrt( (x2-x1)*(x2-x1) + (y2-y1)*(y2-y1) ) +
        sqrt( (x3-x2)*(x3-x2) + (y3-y2)*(y3-y2) ) +
        sqrt( (x4-x3)*(x4-x3) + (y4-y3)*(y4-y3) ) +
        sqrt( (x4-x1)*(x4-x1) + (y4-y1)*(y4-y1) );
}
 
bool operator< (const Trapeze &t1, const Trapeze &t2)
{
    return t1.P < t2.P;
}
 
std::ostream& operator<< (std::ostream &output, const Trapeze &t)
{
    output<< "A("<< t._x1<< ", "<< t._y1<< ")"<< std::endl
          << "B("<< t._x2<< ", "<< t._y2<< ")"<< std::endl
          << "C("<< t._x3<< ", "<< t._y3<< ")"<< std::endl
          << "D("<< t._x4<< ", "<< t._y4<< ")"<< std::endl
          << "P = "<< t.P<< std::endl;
    return output;
}

float volume ()                // ф-я подсчета объема

 maxV=0;
    maxP=NULL;
    mv=0;
    for (int i=0;i<n;i++)
    {
       if (maxV <(*(P+i)).volume())
      { maxV=(*(P+i)).volume();
        maxP=(P+i);
        mv=i;
      }
    }
 
 cout<<"max Trap = "; maxP->output();
 cout << "\n";
 cout<<"max Volume = "<<maxV << endl;

//*****************************************************
//
//       Программа анализа и вычисления значения
//       арифметического выражения Калькулятор
//
//  Можно вводить ар. выражения с операциями +-*/,
//  использовать скобки, имена, оператор присваивания =.
//  Имена можно не объявлять. Инициализация по умолчанию - 0.
//  Выход - ввод пустой строки
//  Версия: 3.0 для Visual C++
//*****************************************************
#include <string>
#include <iostream>
#include <windows.h>
 
using namespace std;
//****************************************************************
// Глобальные определения и объявления
//****************************************************************
int no_of_errors = 0;           // счетчик ошибок
 
enum token_value                // внутреннее представление лексем
{ NAME, NUMBER, END,
  PLUS='+', MINUS='-', MUL='*', DIV='/',
  ASSIGN='=', LP='(', RP=')'
};
 
token_value curr_tok;       // текущая лексема
 
double number_value;        // значение текущей числовой лексемы
const double default_value = 0; // значение переменной по умолчанию
char name_string[256];      // считанное имя для текущей лексемы
 
 
/////////////////////////////////////////////////////////////////////
//  Обработчик ошибок
//  Функция error выдает на экран сообщение об ошибке и
//  увеличивает счетчик ошибок
/////////////////////////////////////////////////////////////////////
int error(const char* s)
{
 
  char buf[256];
  CharToOem(s, buf);
  cout << "error: " << buf << "\n";
  no_of_errors++;  
  ExitProcess(0);
  return 1;
}
 
//****************************************************************
// Динамические структуры и их построение: двоичные деревья
//****************************************************************
struct node
{
  token_value type;
  union
  { double value;
    char *name;
  };
  node *left;  // Левое поддерево
  node *right; // Правое поддерево
};
 
/////////////////////////////////////////////////////////////////////
//   Перегруженная функция new_node создает новую вершину
//   двоичного дерева в зависимости от типа узла: число или имя.
/////////////////////////////////////////////////////////////////////
node *new_node(const token_value type)
{
  node * p = new node;
  p->type = type;
  p->left = p->right = NULL;
  return p;
}
 
//   Создание вершины дерева - числа
node *new_node(const token_value type, const double value)
{
  node * p = new_node(type);
  p->value = value;
  return p;
}
//Создание вершины дерева - имени
node *new_node(const token_value type,const char *name)
{
  node *p = new_node(type);
  p->name = new char[strlen(name)+1];
  strcpy(p->name,name);
  return p;
}
 
//****************************************************************
//   Работа с таблицей имен
//****************************************************************
struct name
{
  char* string;                        // имя переменной
  double value;                        // и связанное с ним значание
};
const int TBLSZ = 23;
name* table[TBLSZ];                    // таблица указателей на переменные
 
/////////////////////////////////////////////////////////////////////
//  Поиск-вставка имени в таблице имен
//  Функция возвращает указатель на найденную переменную(имя) и ее
//  значение
/////////////////////////////////////////////////////////////////////
name* insert(const char* p)
{
  // простой линейный поиск в таблице
  int ii;
  for (ii=0;ii<TBLSZ && table[ii];ii++)
    if (strcmp(p,table[ii]->string) == 0) return table[ii];
 
  if (ii==TBLSZ)
    {error("Нет памяти для вставки нового имени"); return NULL;};
 
  name* nn = new name; // вставка нового имени
  nn->string = new char[strlen(p)+1];
  strcpy(nn->string,p);
  nn->value = default_value; // инициализация по умолчанию
  table[ii++] = nn;
  return nn;
}
 
//****************************************************************
//  Сканер (лексический анализатор).
//  Функция производит ввод из входного потока и возвращает
//  очередную лексему во внутреннем представлении.
//****************************************************************
token_value get_token()
{
  char ch;
  do // игнорирует пропуски, за исключением \n
  { if (!cin.get(ch)) return curr_tok=END;
  } while (ch!='\n' && isspace(ch));
  switch (ch){
 
    case'\n':
      return curr_tok = END;
 
    case'*':
    case'/':
    case'+':
    case'-':
    case'(':
    case')':
    case'=':
      return curr_tok = token_value(ch);
 
    // Выделение числа
    case'0':    case'1':    case'2':    case'3':    case'4':
    case'5':    case'6':    case'7':    case'8':    case'9':
      cin.putback(ch);
      cin >> number_value;
      return curr_tok=NUMBER;
 
    // Выделение имени или ошибка
    default:
      if (isalpha(ch))
      {
    char* p = name_string;
    *p++ = ch;
    while (cin.get(ch) && isalnum(ch)) *p++ = ch;
    cin.putback(ch);
    *p = '\0';
    return curr_tok = NAME;
      }
      error("Плохая лексема");
      return curr_tok=END;
  }
}
 
//****************************************************************
//  Синтаксический анализатор
//  Функции expr(), prim(), term() производят синтанализ
//  соответствующих синтаксический конструкций и формируют
//  двоичные деревья выражений
//****************************************************************
 
node *expr (); // предварительное объявление
 
// Разбор prim. Функция возвращает указатель на дерево, построенное
// из разобранного prim
node *prim ()
{
  node *p;
  switch (curr_tok)
  {
    case NUMBER :       // Число
      get_token();
      return new_node(NUMBER,number_value);
 
    case NAME:                  // Имя
      switch (get_token())
      {
    case ASSIGN:
    {
      p = new_node(ASSIGN);
      p->left = new_node(NAME,name_string);
      get_token();
      p->right = expr();
      return p;
    };
    default:
      return new_node(NAME,name_string);
      }
 
    case PLUS: case MINUS:     // Операция унарный плюс или минус
      p = new_node(curr_tok);
      get_token();
      p->left = new_node(NUMBER,0.0);
      p->right = prim();
      return p;
 
    case LP:                    // Выражение в скобках
      get_token();
      p = expr();
      if (curr_tok != RP) {error("Ожидается )"); return NULL;}
      get_token();
      return p;
 
    default:
      {error("Ожидается primary");return NULL;}
  }
}
 
// Разбор term. Функция возвращает указатель на дерево, построенное
// из разобранного term
node *term ()
{
  node *p;
  node *left = prim();
  for (;;)
    switch (curr_tok)
    {
      case MUL:
      case DIV:
    p = new_node(curr_tok);
    get_token();
    p->left = left;
    p->right = prim();
    left = p;
    break;
 
      default:
    return left;
    }
}
 
// Разбор expr. Функция возвращает указатель на дерево, построенное
// из разобранного expr
node *expr()
{
  node *p;
  node *left = term();
  for (;;)
    switch (curr_tok)
    {
      case PLUS:
      case MINUS:
    p = new_node(curr_tok);
    p->left = left;
    get_token();
    p->right = term();
    left = p;
    break;
 
      default:
    return left;
    }
}
 
/////////////////////////////////////////////////////////////////////
// Вычислитель
// На входе - дерево p, значение которого нужно вычислить
// На выходе - вычисленное вещественное значение
/////////////////////////////////////////////////////////////////////
double eval(node* p)
{
  switch (p->type)
  {
    case NUMBER:
      return p->value;
 
    case NAME:
      return insert(p->name)->value;
 
    case ASSIGN:
      {double e = eval(p->right);
      name *n  = insert((p->left)->name);
      n->value = e;
      return e;
      }
    case PLUS:
      return eval(p->left) + eval(p->right);
 
    case MINUS:
      return eval(p->left) - eval(p->right);
 
    case MUL:
      return eval(p->left) * eval(p->right);
 
    case DIV:
      {
      double d = eval (p->right);
      if (d==0) {error("Деление на н0ль"); return 1;}
      return eval(p->left) / d;
      }
    default:
     {
      error("Не понял?");
      return 1;
      }
  }
}
 
/////////////////////////////////////////////////////////////////////
// Драйвер
// Функция осуществляет ввод в режиме "командной строки",
// обращается к синтаксическому анализатору для разбора выражения
// и построения двоичного дерева выражения, и к вычислителю для
// вычисления значения постороенного двоичного дерева
/////////////////////////////////////////////////////////////////////
int main()
{
  insert("pi")->value=3.1415926535897932384626433832795;
  insert("e")->value=2.718281828459045;
 
  while (cin)                      // Пока входной поток не пуст
  { cout << "calc>";
    get_token ();                  // Берем первую лексему
    if (curr_tok == END) break;    // Если не конец
    cout << eval(expr()) << "\n";  // Строим дерево, вычисляем его и выводим
    if (curr_tok != END) error ("Лишние символы");
  }
  return no_of_errors;
}