Константа в классе

#include <iostream>
 
using namespace std;
 
class Foo{
public:
    Foo();
    const int constanta = 50;
    void Func();
};
 
Foo::Foo(){
    //constanta = 50;
}
 
void Foo::Func(){
 
    int Array[constanta];
}
 
 
 
int main(){
 
    cout << "hello";
 
    cout << endl << endl;
    system("pause");
 
    return 0;
}

class konkretniy{
   static const int konstanta1 = 50;
   static const int konstanta2 = 40;
   static const int konstanta3 = 50;
   static const int konstanta4 = 0.2;
   //.....
};

class konkretniy{
   enum konstanti{konstanta1 = 50, konstanta2 = 40, konstanta3 = 50, konstanta4 = 0.2);
   //.....
};

        //-- table   [   type    ][ enum-id ][   category    ][  type-name  ][ work-status ]
        REGISTER_TYPE( bool      ,  eBOOL    ,  ePRIMITIVE   ,    "BOOL"     ,   ENABLED   );
        REGISTER_TYPE( V::I8     ,  eI8      ,  ePRIMITIVE   ,    "INT8"     ,   ENABLED   );
        REGISTER_TYPE( V::I16    ,  eI16     ,  ePRIMITIVE   ,    "INT16"    ,   ENABLED   );
        REGISTER_TYPE( V::I32    ,  eI32     ,  ePRIMITIVE   ,    "INT32"    ,   ENABLED   );
        REGISTER_TYPE( V::I64    ,  eI64     ,  ePRIMITIVE   ,    "INT64"    ,   ENABLED   );
        REGISTER_TYPE( V::U8     ,  eU8      ,  ePRIMITIVE   ,    "UINT8"    ,   ENABLED   );
        REGISTER_TYPE( V::U16    ,  eU16     ,  ePRIMITIVE   ,    "UINT16"   ,   ENABLED   );
        REGISTER_TYPE( V::U32    ,  eU32     ,  ePRIMITIVE   ,    "UINT32"   ,   ENABLED   );
        REGISTER_TYPE( V::U64    ,  eU64     ,  ePRIMITIVE   ,    "UINT64"   ,   ENABLED   );
        REGISTER_TYPE( V::F32    ,  eF32     ,  ePRIMITIVE   ,    "FLOAT32"  ,   ENABLED   );
        REGISTER_TYPE( V::F64    ,  eF64     ,  ePRIMITIVE   ,    "FLOAT64"  ,   ENABLED   );
        REGISTER_TYPE( V::Byte   ,  eBYTE    ,  ePRIMITIVE   ,    "BYTE"     ,   ENABLED   );
        REGISTER_TYPE( V::WChar  ,  eWCHAR   ,  ePRIMITIVE   ,    "WCHAR"    ,   ENABLED   );
        REGISTER_TYPE( V::Str    ,  eSTRING  ,  ePRIMITIVE   ,    "STRING"   ,   ENABLED   );
        REGISTER_TYPE( V::WStr   ,  eWSTRING ,  ePRIMITIVE   ,    "WSTRING"  ,   ENABLED   );
        REGISTER_TYPE( V::Blob   ,  eBLOB    ,  ePRIMITIVE   ,    "BLOB"     ,   ENABLED   );
        REGISTER_TYPE( V::Record ,  eRECORD  ,  eKEY_VARIANT ,    "RECORD"   ,   ENABLED   );
        REGISTER_TYPE( V::Records,  eRECORDS ,  eASSOCIATIVE ,    "RECORDS"  ,   ENABLED   );
        REGISTER_TYPE( V::Map    ,  eMAP     ,  eASSOCIATIVE ,    "MAP"      ,   ENABLED   );
        REGISTER_TYPE( V::Vec    ,  eVECTOR  ,  eLINEAR      ,    "VECTOR"   ,   ENABLED   );
        REGISTER_TYPE( V::List   ,  eLIST    ,  eLINEAR      ,    "LIST"     ,   ENABLED   );

enum v1{ ev1 };
enum v2{ ev2 };
 
void foo(v1);
void foo(v2);

constexpr int factorial (int n)
{
    return n > 0 ? n * factorial( n - 1 ) : 1;
}

#include <iostream>
 
 
constexpr int factorial (int n)
{
    return n > 0 ? n * factorial( n - 1 ) : 1;
}
 
int main()
{
    std::cout << "Hello, world!\n";
    
    int a = factorial(3);
    
    enum v { b = factorial(3) };
    
    int c = 3;
    
    // уже не является константной времени компиляции
    // вычисление переносится на рантайм
    // при этом компилятор даже и не пикнет
    // не предупредит, что у нас тут просадка первоманса случилась
    const int d = factorial(c);
    
    // --- compile-time protection
    // error: the value of ‘c’ is not usable in a constant expression
    //enum { f = factorial(c) };
    
}

console(HIDE)(CENTER);
    console(RED)  << "ololo\n";
    console(BLUE) << "trololo\n";
console(VISIBLE);

const int v = 10;
const* int p = &v; //<--- скушали память
 
enum v { e }; //<--- здесь пока не будет явно создан объект
  // скушать память не получится
//а явно создать объект енума в статике - это крайне маловероятно

struct Console
{
    enum eFLAGS { 
        eNONE              = 0, 
        eFULLSCREEN     = 1<<1, 
        eDOUBLEBUFFER = 1<<2, 
        eREDIRECT_IO    = 1<<3 
    };
 
    typedef tools::TFlag<eFLAGS> 
        Flag;
 
 
    Console(const eFLAGS flags)
        :mSettings(flags)
    {  ... }
 
    ...
 
    bool IsFullScreen()const { return mFlags.Has(eFULLSCREEN ); }
 
    ...
 
    Flags mFlags;
 
};

mFlags                eDOUBLEBUFFER|eREDIRECT_IO

//ИСПОЛЬЗОВАНИЕ:
 
enum eFLAGS { eCLEAR = 0, eONE = 1<<1, eTWO = 1<<2, eTHREE = 1<<3 };
typedef tools::TFlag<eFLAGS> Flag;
 
Flag f(eONE|eTWO);
EXPECT_EQ(eONE|eTWO,    f.GetByEnumeration()    );
EXPECT_EQ(false,        f.Empty()               );
EXPECT_EQ(true,        (f)? true: false         );
EXPECT_EQ(true,         f.Has(eONE)             );
EXPECT_EQ(true,         f.Has(eONE|eTWO)        );
EXPECT_EQ(false,        f.Has(eONE|eTWO|eTHREE) );
EXPECT_EQ(true,         f.HasAny(eONE|eTWO)     );
EXPECT_EQ(true,         f.HasAny(eTWO|eTHREE)   );
EXPECT_EQ(false,        f.HasOnly(eONE)         );
EXPECT_EQ(true,         f.HasOnly(eONE|eTWO)    );
 
f.ValidOnly(eONE);
 
EXPECT_EQ(eONE,   f.GetByEnumeration()  );
EXPECT_EQ(false,  f.Empty()             );
EXPECT_EQ(true,  (f)? true: false       );
EXPECT_EQ(true,   f.Has(eONE)           );
EXPECT_EQ(false,  f.Has(eONE|eTWO)      );
EXPECT_EQ(true,   f.HasAny(eONE|eTWO)   );
EXPECT_EQ(false,  f.HasAny(eTWO|eTHREE) );
EXPECT_EQ(true,   f.HasOnly(eONE)       );
EXPECT_EQ(false,  f.HasOnly(eONE|eTWO)  );