#include <iostream>

#include <math.h>
using namespace std;
class Tocka
{
public:
float x;
float y;
float z;
Tocka(float x,float y);
Tocka()
{x=0; y=0; z=0;}
Tocka(float x, float y, float z);
Tocka (const Tocka& T);
friend float udaljenost(const Tocka &T1,const Tocka &T2);
};
float udaljenost(const Tocka &T1,const Tocka &T2)
{
return sqrt((T1.x-T2.x)*(T1.x-T2.x)+(T1.y-T2.y)*(T1.y-T2.y)+(T1.z-T2.z)*(
T1.z-T2.z));
}

float P (Tocka T1,Tocka T2,Tocka T3)

{
float a,b,c;
a=udaljenost(T1,T2);
b=udaljenost(T2,T3);
c=udaljenost(T1,T3);
return sqrt((a+b+c)/2*((a+b+c)/2-a)*((a+b+c)/2-b)*((a+b+c)/2-c));
}
Tocka::Tocka(float x,float y)
{
this->x=x;
this->y=y;
z=0;
}
Tocka::Tocka(float x, float y, float z)
{
this->x=x;
this->y=y;
this->z=z;
}
Tocka::Tocka(const Tocka& T)
{
x=T.x;
y=T.y;
z=T.z;
}
class Cetverokut
{
public:
Tocka T1,T2,T3,T4;
Cetverokut()
{}
Cetverokut (Tocka& T1,Tocka& T2,Tocka& T3,Tocka& T4);
float opseg() const;
};

Cetverokut::Cetverokut(Tocka& T1,Tocka& T2,Tocka& T3,Tocka& T4)

{
this->T1=T1;
this->T2=T2;
this->T3=T3;
this->T4=T4;
}
float Cetverokut::opseg() const
{
return udaljenost(T1,T2)+udaljenost(T2,T3)+udaljenost(T3,T4)+udaljenost(T4,T1);
}
class Paralelogram : public Cetverokut
{
public:
Paralelogram(Tocka &T1,Tocka &T2,Tocka &T3,Tocka& T4){
if(udaljenost(T1,T2)==udaljenost(T4,T3) && udaljenost(T4,T1)==udaljenost(T3,T
2))
Cetverokut(T1,T2,T3,T4);
else cout<<"tocke T1,T2,T3,T4, ne tvore paralelogram te se ne moze stvorit objek
t paralelogram"<<endl;
}
float povrsina() const{
float a=udaljenost(T1,T2);
float b=udaljenost(T1,T3);
float c=udaljenost(T3,T2);
float s=(a+b+c)/2;
return 2*sqrt(s*(s-a)*(s-b)*(s-c));
}
};
int main()
{
Tocka T1(6,3);
Tocka T2(4,2);
Tocka T3(5,3);
Tocka T4(1,2);
Paralelogram P(T1,T2,T3,T4);
cout <<"Opseg paralelograma je jednak "<< P.opseg() << endl;
cout <<"Povrsina paralelograma je jednaka "<< P.povrsina() << endl;
return 1;
}
************************************************************
#include<iostream>
using namespace std;
const float pi=3.14;
class Tocka
{
public:
float x;
float y;
Tocka(float x, float y)
{
this->x=x;
this->y=y;
}

};
typedef float radius;
class Krug
{
public:
Krug();
Krug(Tocka &S, radius r)
{
this->S=&S;
this->r=r;
}
float opseg()
{
return 2*r*pi;
}
float povrsina()
{
return r*r*pi;
}
protected:
radius r;
Tocka *S;
};
int main()
{
Tocka T(7,2);
Krug krug(T,4);
cout << "Opseg kruga je: " << krug.opseg() << endl;
cout << "Povrsina kruga je: " << krug.povrsina() << endl;
return 1;
}
*******************************************************************************
#include<iostream>
#include<math.h>
using namespace std;
const int pi=3.14;
class Tocka
{
public:
float x;
float y;
};
typedef float radius;
class Krug
{
public:
Krug(){}
Krug(Tocka S, radius r)
{
this->r=r;
this->S.x=S.x;

this->S.y=S.y;
}
float opseg()
{
return(2*r*pi);
}
float povrsina()
{
return(r*r*pi);
}
bool imaSjeciste(Krug &krug)
{
float X;
float Y;
X=S.x-krug.S.x;
Y=S.y-krug.S.y;
X=X*X;
Y=Y*Y;
float D;
D=sqrt(X+Y);
float R;
R=r+krug.r;
if (R>D)
{
return true;
} else
{
return false;
}
}
protected:
radius r;
Tocka S;
};
int main ()
{
int r=1;
Tocka T;
T.x=4;
T.y=0;
Krug K(T,r);
int r1=2;
Tocka T1;
T1.x=4;
T1.y=9;
Krug K1(T1,r1);
if (K.imaSjeciste(K1))
{
cout << "Ima sjeciste." <<endl;
}else
{
cout << "Nema sjeciste." << endl;
}
return 0;
}
*********************************************

#include<iostream>
#include<math.h>
using namespace std;
class Tocka{
public:
float a,b;
Tocka (){a=1.0; b=1.0;};
Tocka(float a, float b){
this->a=a;
this->b=b;
};
};
class Trokut{
protected:
Tocka A,B,C;
public:
// konstruktor
Trokut(){ Tocka A(1.0, 1.0); Tocka B(1.0, 1.0); Tocka C(1.0, 1.0); }
Trokut(Tocka A, Tocka B, Tocka C){
this->A=A;
this->B=B;
this->C=C;
};
Trokut(const Trokut &T){
this->A=T.A;
this->B=T.B;
this->C=T.C;
};
// metoda za raunanje opsega trokuta
float opsegTr(){
float a1,b1,c1;
a1 = sqrt((C.a-B.a)*(C.a-B.a)+(C.b-B.b)*(C.b-B.b));
b1 = sqrt((C.a-A.a)*(C.a-A.a)+(C.b-A.b)*(C.b-A.b));
c1 = sqrt((B.a-A.a)*(B.a-A.a)+(B.b-A.b)*(B.b-A.b));
return (a1+b1+c1);
};
friend class Tocka;
};
class Kruznica{
protected:
Tocka S;
float r;
public:
// konstruktori
Kruznica(){};
Kruznica(Tocka S, float r){
this->S=S;
this->r=r;
};
Kruznica(const Kruznica &K){
this->S=K.S;
this->r=K.r;
};
// metoda za raunanje opsega kruznice
float opsegKr(){
return (2*r*3.14);

};
};
class OpTrokut:public Trokut, public Kruznica{ // Kruznica je opisana trokutu
public:
// konstruktori
OpTrokut(Tocka A, Tocka B, Tocka C):Trokut(A,B,C),Kruznica(S,r){
float s1,s2,s3,P,xs,ys;
s1 = sqrt((C.a-B.a)*(C.a-B.a)+(C.b-B.b)*(C.b-B.b));
s2 = sqrt((C.a-A.a)*(C.a-A.a)+(C.b-A.b)*(C.b-A.b));
s3 = sqrt((B.a-A.a)*(B.a-A.a)+(B.b-A.b)*(B.b-A.b));
P = 0.25 * sqrt((s1+s2+s3)*(s2+s3-s1)*(s1+s3-s2)*(s1+s2-s3));
r = (s1*s2*s3)/(4*P);
xs = (A.a*A.a*(C.b-A.b)-A.a*B.a*(C.b-B.b)-A.a*A.a*(B.b-A.b)+A.a*C.a*(B.b-A.b))/(
C.a*B.b-C.a*A.b-A.a*B.b-B.a*C.b+B.a*A.b+A.a*C.b);
ys = A.b-(xs*C.a-A.a*C.a-xs*A.a+A.a*A.a)/(C.b-A.b);
S.a = xs;
S.b = ys;
r = r;
//cout << "Srediste kruznice ima koordinate: " << xs << " i " << ys << ", a polu
mjer kruznice je: " << r << endl;
}
OpTrokut(Tocka S, float r);
float opseg(){ // opseg = opseg trokuta + opseg kruznice
return (opsegTr()+opsegKr());
};
};
int main()
{
Tocka A1(2.0,3.0);
Tocka A2(1.0,5.0);
Tocka A3(2.0,7.0);
Trokut T(A1,A2,A3);
cout << "Opseg trokuta je: " << T.opsegTr() << endl;
Tocka S1(2.8,8.9);
float r1 = 5.4;
Kruznica K(S1,r1);
cout << "Opseg kruznice je: " << K.opsegKr() << endl;
cout << endl;
cout << "Za opisanu kruznicu: ";
OpTrokut T1(A1,A2,A3);
cout << T1.opseg() << endl;
return 1;
}

ZADAA
#include <iostream>
#include <math.h>
using namespace std;
class Tocka
{
public:
float x,y;
Tocka (){x=0; y=0;};
Tocka(float x, float y){
this->x=x;
this->y=y;
}
Tocka (const Tocka& T);
};
class Lik
{
public:
virtual void init() = 0;
virtual void povrsina() = 0;
virtual void opseg() = 0;
void status();
};
class Trokut : public Lik
{
private:
Tocka A,B,C;
public:
Trokut() { Tocka A(1.0, 1.0); Tocka B(1.0, 1.0); Tocka C(1.0, 1.0); };
Trokut(Tocka &A, Tocka &B, Tocka &C){
this->A=A;
this->B=B;
this->C=C;
};
Trokut(const Trokut &T){
this->A=T.A;
this->B=T.B;
this->C=T.C;

};
// metoda za racunanje opsega trokuta
float opsegTrokuta(){
float a,b,c;
a = sqrt((C.x-B.x)*(C.x-B.x)+(C.y-B.y)*(C.y-B.y));
b = sqrt((C.x-A.x)*(C.x-A.x)+(C.y-A.y)*(C.y-A.y));
c = sqrt((B.x-A.x)*(B.x-A.x)+(B.y-A.y)*(B.y-A.y));
return (a+b+c);
};
friend class Tocka;
};
/*
//metoda za racunanje povrsine trokuta
float povrsinaTrokuta(){
float a,b,c,s;
a = (C.x-B.x)*(C.x-B.x)+(C.y-B.y)*(C.y-B.y);
b = (C.x-A.x)*(C.x-A.x)+(C.y-A.y)*(C.y-A.y);
c = (B.x-A.x)*(B.x-A.x)+(B.y-A.y)*(B.y-A.y);
s = (a+b+c)/2;
return (sqrt(s*(s-a)*(s-b)*(s-c)));
};
//metoda za racunanje radijusa upisane kruznice
float radiusUpKruz(){
float a,b,c,s,P;
a = (C.x-B.x)*(C.x-B.x)+(C.y-B.y)*(C.y-B.y);
b = (C.x-A.x)*(C.x-A.x)+(C.y-A.y)*(C.y-A.y);
c = (B.x-A.x)*(B.x-A.x)+(B.y-A.y)*(B.y-A.y);
s = (a+b+c)/2;
P = sqrt(s*(s-a)*(s-b)*(s-c));
return (P/s);
};
};
*/
class Krug : public Lik
{
private:
Tocka S;
float radius;
public:
Krug(){};
Krug(Tocka &S,float r){
this->S=S;
this->radius=r;
};
// metoda za raunanje opsega kruga
float opsegKr(){
return (2*radius*3.14);
};
//metoda za racunanje povrsine kruga
float povrsinaKruga(){
return (radius*radius*3.14);
};
};
class PravilniPoligon : public Lik
{
private:
int N;
Tocka *vrhovi;
public:

PravilniPoligon(){};
PravilniPoligon(Tocka *vrhovi, int N);
};
int main()
{
Tocka T1(6.0,3.0);
Tocka T2(4.0,2.0);
Tocka T3(5.0,3.0);
Trokut T(T1,T2,T3);
cout <<"Opseg trokuta je jednak "<< T.opsegTrokuta() << endl;
cout <<"Povrsina trokuata je jednaka "<< T.povrsinaTrokuta() << endl;
cout <<"Polumjer upisane kruznice trokuta jednaka je "<< T.radiusUpKruz() << end
l;
Tocka S(4.0,2.0);
Krug K(S,4.0);
cout <<"Opseg kruga je jednak "<< K.opsegKruga() << endl;
cout <<"Povrsina kruga je jednaka "<< K.povrsinaKruga() << endl;
return 1;
}