Зачем нужны объекты?

#ifndef AngleH
#define AngleH
//---------------------------------------------------------------------------
#include "defines.h"
#include "Vector.h"
const double M_2xPI=M_PI*2;
const scalar AngleScales[4]={M_2xPI,360.,400.,1.};
typedef enum {ptRadians=0,ptDegrees,ptGrads,ptCycles}TAngleScale;
typedef enum {auDegrees=0,auDegreesDec,auGrads,auRadians,auCycles}TAngleUnit;
class TAngle{
private:
      scalar FValue;
protected:
      scalar __fastcall GetRadians(){return Value*M_2xPI;};
      scalar __fastcall GetDegrees(){return Value*360.;};
      scalar __fastcall GetGrads(){return Value*400.;};
      scalar __fastcall GetScale(TAngleScale n){return Value*AngleScales[n];};
      scalar __fastcall GetCustomScale(scalar aScale){return Value*aScale;};
      void __fastcall SetRadians(scalar New){Value=New/M_2xPI;};
      void __fastcall SetDegrees(scalar New){Value=New/360.;};
      void __fastcall SetGrads(scalar New){Value=New/400.;};
      void __fastcall SetScale(TAngleScale n,scalar New){Value=New/AngleScales[n];};
      void __fastcall SetCustomScale(scalar aScale,scalar New){Value=New/aScale;};
      void __fastcall SetValue(scalar New){FValue=New-(int)New;if (FValue<0) FValue=1+FValue;else if (FValue==1)FValue=0;};
      TVector __fastcall GetVector(){scalar c,s; SinCos(Radians,&s,&c); return TVector(c,s,0);};
      void __fastcall SetVector(TVector New){Radians=ArcTan2(New.y,New.x);};
public:
      __property scalar Scale[TAngleScale ScaleId]={read=GetScale,write=SetScale};
      __property scalar CustomScale[scalar aScale]={read=GetCustomScale,write=SetCustomScale};
      __property scalar Radians={read=GetRadians,write=SetRadians};
      __property scalar Degrees={read=GetDegrees,write=SetDegrees};
      __property scalar Grads={read=GetGrads,write=SetGrads};
      __property TVector Vector={read=GetVector,write=SetVector};
      __property scalar Value={read=FValue,write=SetValue};
      __fastcall TAngle(){FValue=0;};
      __fastcall TAngle(scalar V){Value=V;};
      TAngle __fastcall operator -(){TAngle A; A.Value=-Value;return A;};
 
      TAngle& __fastcall operator -=(const TAngle &Angle){Value-=Angle.Value;return *this;};
      TAngle& __fastcall operator +=(const TAngle &Angle){Value+=Angle.Value;;return *this;};
      TAngle& __fastcall operator *=(const scalar& V){Value*=V;return *this;};
      TAngle& __fastcall operator /=(const scalar& V){Value/=V;return *this;};
 
      TAngle __fastcall operator *(const scalar& V){TAngle A; A.Value=Value*V;return A;};
      TAngle __fastcall operator /(const scalar& V){TAngle A; A.Value=Value/V;return A;};
      TAngle __fastcall operator +(const TAngle& A){TAngle R; R.Value=Value+A.Value;return R;};
      TAngle __fastcall operator -(const TAngle& A){TAngle R; R.Value=Value-A.Value;return R;};
      scalar __fastcall operator /(const TAngle& A){return Value/A.Value;};
 
      bool __fastcall operator ==(const TAngle &Angle){return Value==Angle.Value;};
      bool __fastcall operator !=(const TAngle &Angle){return Value!=Angle.Value;};
      bool __fastcall operator <=(const TAngle &Angle){return Value>=Angle.Value;};
      bool __fastcall operator >=(const TAngle &Angle){return Value<=Angle.Value;};
      bool __fastcall operator >(const TAngle &Angle){return Value>Angle.Value;};
      bool __fastcall operator <(const TAngle &Angle){return Value<Angle.Value;};
};
#endif

class Counter
{
private:
    int x = 0;
public:
    int count() { ++x; return x; }
};
 
int main()
{
    Counter c;
    cout << c.count(); // побочный эффект - счётчик увеличен
    cout << c.count(); // результат отличается от предыдущего вызова c.count();
    return;
}