For Partial - POO, God pls help

#######################################
                TRIUNGHI
#######################################

#include<stdio.h>
#include<conio.h>
#include<iostream>
#include<math.h>
#pragma warning(disable:4996)

using namespace std;

class Punct;

class Triunghi {
private:
    int n;
    Punct *varfuri;
public:
    Triunghi(int n, Punct v[]);
    ~Triunghi();
    double getPerimetru();
    double getArie();
    void verificare();
    void afisare();

};

class Punct {
private:
    double x, y;
public:
    Punct(double x = 0, double y = 0);
    friend void Triunghi::afisare();
    friend double lungime(Punct A, Punct B);
};


Punct::Punct(double x, double y) {
    this->x = x;
    this->y = y;
}

double lungime(Punct A, Punct B) {
    return sqrt(pow(int(B.x) - int(A.x), 2) + pow(int(B.y) - int(A.y), 2));
}

Triunghi::Triunghi(int n, Punct v[]) {
    this->n = n;
    varfuri = new Punct[n];
    for (int i = 0; i < n; i++) {
        varfuri[i] = v[i];
    }
}

void Triunghi::afisare() {
    cout << "[";
    for (int i = 0; i<n; i++) {
        cout << "(" << varfuri[i].x << ","
            << varfuri[i].y << ")";
    }
    cout << "]";
}

double Triunghi::getPerimetru() {
    double p = 0;
    int i=0;
    p = lungime(varfuri[0], varfuri[1]) + lungime(varfuri[1], varfuri[2]) + lungime(varfuri[2], varfuri[0]);
    return p;

}

double Triunghi::getArie() {
    double a = 1;
    double p = getPerimetru();
    double sp = p / 2;
    a = sqrt(sp*(sp - lungime(varfuri[0], varfuri[1]))*(sp - lungime(varfuri[1], varfuri[2]))*(sp - lungime(varfuri[2], varfuri[0])));

    return a;
}

void Triunghi::verificare(){
    while (n != 3) {
        cout<<"Un triunghi are 3 puncte. n= ";
        cin >> n;
    }

    if (((lungime(varfuri[0], varfuri[1]) + lungime(varfuri[1], varfuri[2])) > lungime(varfuri[2], varfuri[0])) &&
        ((lungime(varfuri[1], varfuri[2]) + lungime(varfuri[2], varfuri[0])) > lungime(varfuri[1], varfuri[0])) &&
        ((lungime(varfuri[2], varfuri[0]) + lungime(varfuri[1], varfuri[0])) > lungime(varfuri[1], varfuri[2]))) {
        printf("\nPunctele formeaza un triunghi.");
    }
    else {
        printf("\nPunctele nu pot forma un triunghi.");
        _getch();
        exit(0);
    }
}


Triunghi::~Triunghi() {
    delete[]varfuri;
}


void main() {
    Punct b[3] = { Punct(0, 0), Punct(4,0), Punct(0,3) };
    Triunghi t(3, b);
    t.afisare();
    t.verificare();

    printf("\n Perimetrul este %.2f.", t.getPerimetru());
    printf("\n Aria este: %.2f.", t.getArie());

    _getch();
}


#######################################
                Persoana
#######################################

#include<stdio.h>
#include<conio.h>
#include<iostream>
#pragma warning(disable:4996)

using namespace std;

class Persoana {
protected:
    char *nume;
    int varsta;
public:
    Persoana(char *nume = " ", int varsta = 0);
    Persoana(const Persoana&p);
    ~Persoana();
    void print();
};

Persoana::Persoana(char *nume, int varsta) {
    this->varsta = varsta;
    if (nume != NULL) {
        this->nume = new char[strlen(nume) + 1];
        strcpy(this->nume, nume);
    }
    else
        this->nume = NULL;
}

Persoana::Persoana(const Persoana&p) {
    varsta = p.varsta;
    if (p.nume != NULL) {
        nume = new char[strlen(p.nume) + 1];
        strcpy(nume, p.nume);
    }
    else
        nume = NULL;

}

Persoana::~Persoana() {
    if (nume != NULL)
        delete nume;
    nume = NULL;
}

void Persoana::print() {
    cout << "Numele: " << nume;
    cout << "\nVarsta: " << varsta;
}

class Student:public Persoana {
protected:
    char *facultate;
public:
    Student(char *nume, int varsta, char *facultate) :Persoana(nume, varsta) {
        if (facultate != NULL) {
            this->facultate = new char[strlen(facultate) + 1];
            strcpy(this->facultate, facultate);
        }
        else
            this->facultate = NULL;
    }

    Student(const Student &s) :Persoana(nume, varsta) {
        if (s.facultate != NULL) {
            facultate = new char[strlen(s.facultate) + 1];
            strcpy(facultate, s.facultate);
        }
        else
            facultate = NULL;
    }

    ~Student(){
        if (facultate != NULL)
            delete facultate;
        facultate = NULL;
    }

    void print() {
        cout << "\n\nNumele: " << nume;
        cout << "\nVarsta: " << varsta;
        cout << "\nFacultatea: " << facultate;
    }

};

void main() {
    Persoana p1("Ion", 12);
    p1.print();
    Student s1("Andrei", 23, "Info");
    s1.print();

    _getch();
}
#######################################
        Polinom fara get x , y
#######################################
#include<stdio.h>
#include<conio.h>
#include<iostream>

using namespace std;

class Polinom {
private:
    int n;
    double *coef;
public:
    Polinom();
    Polinom(int n);
    Polinom(const Polinom &p);
    ~Polinom();
    void citire();
    void afisare();
    Polinom &operator=(const Polinom&);
    friend Polinom operator +(Polinom p, Polinom q);
};

Polinom::Polinom() {

}

Polinom::Polinom(int n) {
    this->n = n;
    this->coef = new double[n + 1];
    for (int i = 0; i < n+1; i++)
        coef[i] = 0;
}

Polinom::Polinom(const Polinom &p) {
    n = p.n;
    coef = new double[n + 1];
    for (int i = 0; i < n+1; i++) {
        coef[i] = p.coef[i];
    }
}

Polinom::~Polinom() {
    delete[]coef;
}

void Polinom::citire() {
    int g;                                              //se poate fara citirea gradului
    cout << "Gradul polinomului este: ";
    cin >> g;
    if (n > g) {
        delete coef;
        coef = new double[n + 1];
    }

    n = g;

    cout << "Coeficientii sunt: \n";
    for (int i = 0; i < n+1; i++) {
        cout << "coef[" << i << "]= ";
        cin >> coef[i];
    }
}

void Polinom::afisare() {
    for (int i = 0; i < n+1; i++) {
        if (coef[i] > 0 && i != 0)
            cout << "+" << coef[i]<<"X^"<<i;
        else
            cout << coef[i]<<"X^"<<i;

    }
    printf("\n");
}

Polinom& Polinom::operator=(const Polinom &p) {
    if (this != &p) {
        if (n != p.n)
            delete[]coef;
        n = p.n;
        coef = new double[n + 1];
        for (int i = 0; i < n + 1; i++)
            coef[i] = p.coef[i];
    }
    return *this;
}

Polinom operator+(Polinom p1, Polinom p2) {
    int max = (p1.n > p2.n) ? p1.n : p2.n;
    Polinom r(max);
    for (int i = 0; i < p1.n; i++)
        r.coef[i] += p1.coef[i];
    for (int i = 0; i < p2.n; i++)
        r.coef[i] += p2.coef[i];

    return r;
}

void main() {
    Polinom p1(2);
    Polinom p2(3);

    p1.citire();
    p1.afisare();
    p2.citire();
    p2.afisare();

    Polinom p3 = p1 + p2;
    p3.afisare();


    _getch();
}


#######################################
                Vector
#######################################

#include<stdio.h>
#include<conio.h>
#include<iostream>
#pragma warning (disable:4996)

using namespace std;


class Vector {
private:
    int n;
    float *t;
public:
    Vector(int n);
    Vector(const Vector &v);
    int getSize();
    float getElement(int i);
    void setElement(int i, float val);
    ~Vector();
    void citire();
    void afisare();
};


Vector::Vector(int n){
    this->n = n;
    t = new float[n];
    for (int i = 0; i < n; i++)
        t[i] = 0;
}

Vector::Vector(const Vector &v) {              //constructor de copiere
    n = v.n;
    t = new float[n];
    for (int i = 0; i < n; i++) {
        t[i] = v.t[i];
    }
}

Vector::~Vector() {
    delete t;
}

void Vector::citire() {
    int m;
    cout << "Dati dimensiunea vectorului: ";
    cin >> m;
    if (n > m) {
        delete t;
        t = new float[n];
    }
    n = m;

    for (int i = 0; i < n; i++) {
        cout << "Elementul[" << i << "] = ";
        cin >> t[i];
    }
}

void Vector::afisare() {
    cout << "[";
    for (int i = 0; i < n; i++)
        cout << t[i] << " ";
    cout << "]";
}

int Vector::getSize() {
    return n;
}

float Vector::getElement(int i) {
    if (i >= 0 && i < n)
        return t[i];
    else
        return 0;
}

void main() {
    Vector v(3);
    v.citire();
    v.afisare();

    _getch();
}

#######################################
                Fractie
#######################################
class Fractie {
private:
    int numarator;
    int numitor;
public:
    Fractie(int a = 0, int b = 1);
    void citire();
    void afisare();
    void simplificare();

};

Fractie::Fractie(int a, int b) {
    numarator = a;
    numitor = b;
    printf("Apel constructor\n");
}

void Fractie::citire() {
    printf("Dati numaratorul: ");
    scanf("%d", &numarator);
    printf("Dati numitorul: ");
    scanf("%d", &numitor);
}

void Fractie::afisare() {
    printf("%d/%d\n", numarator, numitor);

}

int cmmdc(int a, int b) {
    if (a == b) {
        return a;
    }
    else {
        if (a > b) {
            return cmmdc(a - b, b);
        }
        else
            return cmmdc(a, b - a);
    }
}

void Fractie::simplificare() {
    int cmmdcval;
    cmmdcval = cmmdc(numarator, numitor);
    printf("cmmdc= %d\n", cmmdcval);
    numarator = numarator / cmmdcval;
    numitor = numitor / cmmdcval;

}


int main() {
    Fractie f(9, 3);
    f.afisare();
    Fractie f1;
    f1.citire();
    f1.afisare();
    f1.simplificare();
    f1.afisare();


    _getch();
#######################################
                Segment
#######################################
class Segment;

class Punct {
private:
    float x;
    float y;
public:
    Punct(float a = 0, float b = 0);
    void citire();
    void afisare();
    float getx();
    float gety();

};

float Punct::getx() {
    return x;
}

float Punct::gety() {
    return y;
}

class Segment {
    Punct A;
    Punct B;
public:
    Segment(Punct O, Punct V);
    double lungime();
};

Punct::Punct(float a, float b) {
    x = a;
    y = b;
    printf("Apel constructor\n");

}

void Punct::citire() {
    printf("Dati coordonata x= ");
    scanf("%f", &x);
    printf("Dati coordonata y= ");
    scanf("%f", &y);
}

void Punct::afisare() {
    printf("A(%.2f, %.2f)", x, y);
}

Segment::Segment(Punct O, Punct V) {
    A = O;
    B = V;
    printf("Apel constructor.");
}

double Segment::lungime() {
    return sqrt(pow(int(B.getx) - int(A.getx), 2) + pow(int(B.gety) - int(A.gety), 2));

}


void main() {
    Punct A;
    A.citire();
    A.afisare();
    Punct B;
    B.citire();
    B.afisare();
    Segment s(A, B);
    printf("Lungimea segmentului este: %f.", s.lungime());


    _getch();
}
#######################################
            Perimetru Poligon
#######################################

#includestdio.h
#includeconio.h
#includeiostream
#includemath.h

using namespace std;

class Punct;

class PoligonConvex {
    Punct varfuri;
    int n;
public
    PoligonConvex();
    PoligonConvex(int n, Punct v[]);
    double getPerimetru();
    ~PoligonConvex();
    void afiseaza();
};

PoligonConvexPoligonConvex() {

}

class Punct {
private
    double x, y;
public
    Punct(double x = 0, double y = 0);
    friend void PoligonConvexafiseaza();
    friend double lungime(Punct A, Punct B);
};


PunctPunct(double x, double y) {
    this-x = x;
    this-y = y;
}

double lungime(Punct A, Punct B) {
    return sqrt(pow(int(B.x) - int(A.x), 2) + pow(int(B.y) - int(A.y), 2));

}

double PoligonConvexgetPerimetru() {
    double p = 0;
    int i;
    for (i = 0; i  n-1; i++) {
        p = p + lungime(varfuri[i], varfuri[i + 1]);
    }
    p = p + lungime(varfuri[i - 1], varfuri[0]);
    return p;
}

PoligonConvexPoligonConvex(int n, Punct v[]) {
    this-n = n;
    varfuri = new Punct[n];
    for (int i = 0; in; i++) {
        varfuri[i] = v[i];
    }
}


PoligonConvex~PoligonConvex() {
    delete[]varfuri;
}


void PoligonConvexafiseaza() {
    cout  [;
    for (int i = 0; in; i++) {
        cout  (  varfuri[i].x  ,
             varfuri[i].y  );
    }
    cout  ];
}

void main() {
    Punct t[3] = { Punct(0,0), Punct(3,0),
        Punct(3,4) };
    PoligonConvex p(3, t);
    p.afiseaza();
    int perimetru = p.getPerimetru();
    printf(n Perimetrul este %d., perimetru);

    _getch();
}