double foo( double x )
{
    static const sin_pi_6 = sin( pi / 6 );
    return use_it( sin_pi_6, x );
}

automatic const double

E>И главное, в чём смысл этой бескомпромиссной борьбы со статическими в функциях числами?

class CMyFormulaCalculator {
public:
   static double Process( double x, double y, double z )
   {
       const double A = 0.928745;
       const double B = 0.98455096;
       const double C = 0.023756;

       static const double ABC = formulaPart1( A, B, C );
       static const double BCA = formulaPart2( B, C, A );
       static const double CAB = formulaPart3( C, A, B );

       return ABC * formulaPart3( z, x, y ) + BCA * formulaPart1( x, y, z) + CAB * formulaPart2( y, z, x );
   }

private:
   // Эти три функции вычисляются очень долго.
   static double formulaPart1( double x, double y, double z );
   static double formulaPart2( double x, double y, double z );
   static double formulaPart3( double x, double y, double z );
};

E>class CMyFormulaCalculator {
E>public:
E>   static double Process( double x, double y, double z )
E>   {
E>       const double A = 0.928745;
E>       const double B = 0.98455096;
E>       const double C = 0.023756;

E>       static const double ABC = formulaPart1( A, B, C );
E>       static const double BCA = formulaPart2( B, C, A );
E>       static const double CAB = formulaPart3( C, A, B );

E>       return ABC * formulaPart3( z, x, y ) + BCA * formulaPart1( x, y, z) + CAB * formulaPart2( y, z, x );
E>   }

E>private:
E>   // Эти три функции вычисляются очень долго.
E>   static double formulaPart1( double x, double y, double z );
E>   static double formulaPart2( double x, double y, double z );
E>   static double formulaPart3( double x, double y, double z );
E>};

E>Или в два раза -- это не смысл?

class CCalculateFormulaPart
{
protected:
    BOOL _bCalculated;
    double _fResult;
public:
    CCalculateFormulaPart() : _bCalculated(0) {}
    virtual double Calculate(double) = 0;
};

class CCalculateFormulaPart_1 : public CCalculateFormulaPart
{
    double Calculate(double f)
    {
        if(!_bCalculated)
        {
            _fResult = formulaPart1(f);
            _bCalculated = TRUE;
        }
        return _fResult;
    }
};

E>       const double A = 0.928745;
E>       const double B = 0.98455096;
E>       const double C = 0.023756;

E>       const double ABC = _formulaPart_1.Calculate(A);
E>       const double BCA = _formulaPart_2.Calculate(B);
E>       const double CAB = _formulaPart_3.Calculate(C);

E>       return ABC * formulaPart3( z, x, y ) + BCA * formulaPart1( x, y, z) + CAB * formulaPart2( y, z, x ); // тут можно дополнить классы CCalculateFormulaPart_I, чтобы вызывать эти функции из них - для полного счастья :)

D>Эти 4 класса добавляют (если не считать базового) по 3 строки кода к вызову функции. Это усложняет? Базовый класс написан для того, чтобы уменьшить количество кода и упростить логику производных классов А синглетонов там нет, их там и не нужно.

foo()
{
    CCalculateFormulaPart_1 calculator;
    double v1 = calculator.Calculate( a1 );
    double v2 = calculator.Calculate( a2 );
    assert( v1 == v2 ); // сюрприз! сюрприз! сюрприз!!!
}

E>>Да ты никогда в жизни не поймёшь что надо поменять в такой программе, когда что-то поменяется в математеке

D>Да какое же это чудовище? Мне оно кажется и симпатичнее и выразительнее. Хотя о вкусах не спорят. И по — моему в таком коде разобраться таки — проще.

void foo()
{
    static int const x = expr();
    ..... x .....
}

//-----------------

struct StaticX
{
    int value;
    bool done;
};
static StaticX sx = {0,false};

void foo()
{
    if(!sx.done) sx.value = expr();
    int const x = sx.value;
}

//-----------------

struct StaticX
{
    int value;
    bool done;
    int EvalOnce()
    {
        if(!done) value = expr();
        return value;
    }
};
static StaticX sx = {0,false};

void foo()
{
    int const x = sx.EvalOnce();
}

D>class CCalculateFormulaPart
D>{
D>protected:
D>    BOOL _bCalculated;
D>    double _fResult;
D>public:
D>    CCalculateFormulaPart() : _bCalculated(0) {}
D>    virtual double Calculate(double) = 0;
D>};

D>class CCalculateFormulaPart_1 : public CCalculateFormulaPart
D>{
D>    double Calculate(double f)
D>    {
D>        if(!_bCalculated)
D>        {
D>            _fResult = formulaPart1(f);
D>            _bCalculated = TRUE;
D>        }
D>        return _fResult;
D>    }
D>};

class CalculateFormula
{
    bool done;
    double value;
public:
    CalculateFormula() : done(false) {}
    double Calculate()
    {
        if(!done) value = DoCalculate();
        return value;
    }
protected:
    virtual double DoCalculate() = 0;
};

К>class CalculateFormula
К>{
К>    bool done;
К>    double value;
К>public:
К>    CalculateFormula() : done(false) {}
К>    double Calculate()
К>    {
К>        if(!done)
        {
            done = true;
К>             value = DoCalculate();
        }
К>        return value;
К>    }
К>protected:
К>    virtual double DoCalculate() = 0;
К>};

D> Если нужны несколько похожих классов, которые включают одинаковые данные или функции, то все общее для этих классов проще вынести в базовый класс. По крайней мере Страуструп ( интересная фамилия) это рекомендует и многие с ним согласны. Хотя и не все.

namespace shapes { 
    class rectangle {
        point first; // usualy left-bottom point
        point secont; // usualy up-top point
    };

    class triangle {
        point first; // usualy mostly left point
        point second; // usualy mostly top point
        point last; 
    };
} // namespace shapes

namespace ???_platform
{
    bool IsSuperDevice()
    {
#ifndef UNDER_CE
        return false;
#else
        static bool isSuperDevice = FileFuncs::IsFileExist(_T("\\Windows\\superdevice.dll"));
        return isSuperDevice;
#endif
    }
}

#include <iostream>

int f()
{
    std::cout << "F" << std::endl;
    return 42;
}

int g()
{
    static int const x = f();
    return x;
}

int main()
{
    //g();
}

:-)