С++ - добро... :) - C/C++

По мотивам эпохального топика "С — зло...

" http://www.rsdn.ru/forum/cpp.applied/4109801.1.aspx

struct SchoolInt
{
  int i;
  operator const int&() const { return i; }
  operator       int&()       { return i; }
  // other int operations like ++ etc
  
  struct SIA
  {
    SchoolInt& h;
    const int& x;
    mutable bool not_assigned_yet;
    
    template<class U> operator U() const
    {
      // Looks like you wrote if( a = b ) instead of if( a == b ).
      // If you really want to assign inside if-condition, do if( int(a = b) ).
      BOOST_STATIC_ASSERT(( ! boost::is_same< U, bool >::value ));
      not_assigned_yet=false;
      return h.i=x;
    }
    ~SIA() { if (not_assigned_yet) h.i=x; }
  };
  
  template<class RHS>
  SIA operator=(const RHS& x)
  {
    // Looks like you wrote int_a = bool_b.
    // SchoolInt is strict, please cast explicitly: int_a = (int)bool_b.
    BOOST_STATIC_ASSERT(( boost::is_same< RHS, int >::value ));
    SIA ret = {*this, x, true};
    return ret;
  }
};

Проверка:

int main()
{  
  SchoolInt i = { 5 };
  std::cout << i << std::endl;
  
  i = 14;                       // compiles
  std::cout << i << std::endl;
  
  double y = i = 13;            // compiles
  std::cout << i << " y=" << y << std::endl;
    
  //bool z = int(i = 12);       // compiles
  bool z = i = 12;              // doesn't compile
  std::cout << i << " z=" << z << std::endl;
    
  if ( int x = i = 11 )         // compiles
  std::cout << i << " x=" << x << std::endl;
  
  //if ( bool w = int(i = 10) ) // compiles
  if ( bool w = i = 10 )        // doesn't compile
  std::cout << i << " w=" << w << std::endl;
  
  //if ( int(i = 9) )           // compiles
  if ( i = 9 )                  // doesn't compile
    std::cout << i << std::endl;
  
  //if ( int(i = int(!0) ) )    // compiles
  if ( i =! 0 )                 // doesn't compile
    std::cout << i << std::endl;
}

Всех с тяпницей!

Здравствуйте, jazzer, Вы писали:

Так что вы хотели сказать? Что лучше С++ чем С использовать?

Пример ваш прозрачный, ничего страшного/злого/непонятного я не обнаружил.
Есть стандарты и жеские правила оформления кода, в примере они проигнорированы и конечно создается впечатление что работает что то не так, например оператор = а уж темболее =! вообще разве уместно писать в блоке if ()? Беглый взгляд человека, который будет искать ошибку в мегобайтах кода просто упустит вашу хитрую мысль.

Оператор же реализован для (int) темплейта а пытаются ему подмешать (bool) именно подмешать, из-за того что код оформлен позорно!

Здравствуйте, sof.bix, Вы писали:

SB>Здравствуйте, jazzer, Вы писали:

SB>Так что вы хотели сказать? Что лучше С++ чем С использовать?
Этот код не в вакууме, он создан как ответ на то, что по ссылке. Прочитайте ее, пожалуйста.
Если так уж лень читать, суть в том, что студенты/школьники, только-только приступившие к изучению языка, делают глупые ошибки (типа а=!0) и потом не могут их найти, потому что все замечательно компилируется, просто работает неправильно. У меня же оно просто не компилируется, т.е. такие ошибки не пройдут дальше компилятора.

ЗЫ А еще сегодня пятница

ЗЗЫ А еще там смайлик в сабже есть, он обычно обозначает шутку или что-то в этом роде.

SB>>Здравствуйте, jazzer, Вы писали:

SB>>Так что вы хотели сказать? Что лучше С++ чем С использовать?
J>Этот код не в вакууме, он создан как ответ на то, что по ссылке. Прочитайте ее, пожалуйста.
J>Если так уж лень читать, суть в том, что студенты/школьники, только-только приступившие к изучению языка, делают глупые ошибки (типа а=!0) и потом не могут их найти, потому что все замечательно компилируется, просто работает неправильно. У меня же оно просто не компилируется, т.е. такие ошибки не пройдут дальше компилятора.

J>ЗЫ А еще сегодня пятница

J>ЗЗЫ А еще там смайлик в сабже есть, он обычно обозначает шутку или что-то в этом роде.

Дошутишься пятничник)) Доброе, топик читал, только он непонятный, вот почитал к нему коментарии в дереве и понял к чему вы клоуните))

Здравствуйте, sof.bix, Вы писали:

SB>Дошутишься пятничник)) Доброе, топик читал, только он непонятный, вот почитал к нему коментарии в дереве и понял к чему вы клоуните))

Раз понял — снимай свой минус!

Здравствуйте, sof.bix, Вы писали:

SB>Здравствуйте, jazzer, Вы писали:

SB>Так что вы хотели сказать? Что лучше С++ чем С использовать?

SB>Пример ваш прозрачный, ничего страшного/злого/непонятного я не обнаружил.
SB>Есть стандарты и жеские правила оформления кода

Простите за оффтоп...

но вот опечатка "жеские".
Что вы имели в виду?
жесТкие или жеНские ? Спрашиваю, ибо поведение некоторых участников эпической дискуссии наводит на мысли...

Здравствуйте, blackhearted, Вы писали:

B>но вот опечатка "жеские".
B>Что вы имели в виду?
B>жесТкие или жеНские ? Спрашиваю, ибо поведение некоторых участников эпической дискуссии наводит на мысли...

жесТкие
Какой вы внимательный, обычно люди чтают первую и последнюю букву а вы прям в серединку угодили, и мысли наверное навелись интересные) тяпничные))

Здравствуйте, jazzer, Вы писали:

J>По мотивам эпохального топика "С — зло...

" http://www.rsdn.ru/forum/cpp.applied/4109801.1.aspx
J>

J>struct SchoolInt...
J>

Да тогда сразу заварганить Boost.SchoolTypes, что уж мелочится-то?

Здравствуйте, jazzer, Вы писали:

а вот и ягодки:

Скрытый текст

template <typename _Type> class TValue
{
public:
    typedef TDelegate<void(_Type& value, const _Type& prev)> ESet;
    typedef TDelegate<void(const _Type& value)> EFinalize;

private:
    _Type _Value;

private:
    _Type& _Set(const _Type& value)
    {
        if (OnSet)
        {
            const _Type prev = _Value;
            _Value = value;
            OnSet(_Value, prev);
        }
        else
            _Value = value;

        return _Value;
    }
    _Type& _Set2()
    {
        if (OnSet)
        {
            const _Type prev = _Value;
            ++_Value;
            OnSet(_Value, prev);
        }
        else
            ++_Value;

        return _Value;
    }
    _Type& _Set3()
    {
        if (OnSet)
        {
            const _Type prev = _Value;
            --_Value;
            OnSet(_Value, prev);
        }
        else
            --_Value;

        return _Value;
    }
    _Type& _Set4(const _Type& value)
    {
        if (OnSet)
        {
            const _Type prev = _Value;
            _Value += value;
            OnSet(_Value, prev);
        }
        else
            _Value += value;

        return _Value;
    }
    _Type& _Set5(const _Type& value)
    {
        if (OnSet)
        {
            const _Type prev = _Value;
            _Value -= value;
            OnSet(_Value, prev);
        }
        else
            _Value -= value;

        return _Value;
    }
    _Type& _Set6(const _Type& value)
    {
        if (OnSet)
        {
            const _Type prev = _Value;
            _Value *= value;
            OnSet(_Value, prev);
        }
        else
            _Value *= value;

        return _Value;
    }
    _Type& _Set7(const _Type& value)
    {
        if (OnSet)
        {
            const _Type prev = _Value;
            _Value /= value;
            OnSet(_Value, prev);
        }
        else
            _Value /= value;

        return _Value;
    }
    _Type& _Set8(const _Type& value)
    {
        if (OnSet)
        {
            const _Type prev = _Value;
            _Value %= value;
            OnSet(_Value, prev);
        }
        else
            _Value %= value;

        return _Value;
    }
    _Type& _Set9(const _Type& value)
    {
        if (OnSet)
        {
            const _Type prev = _Value;
            _Value &= value;
            OnSet(_Value, prev);
        }
        else
            _Value %= value;

        return _Value;
    }
    _Type& _Set10(const _Type& value)
    {
        if (OnSet)
        {
            const _Type prev = _Value;
            _Value |= value;
            OnSet(_Value, prev);
        }
        else
            _Value %= value;

        return _Value;
    }
    _Type& _Set11(const _Type& value)
    {
        if (OnSet)
        {
            const _Type prev = _Value;
            _Value ^= value;
            OnSet(_Value, prev);
        }
        else
            _Value ^= value;

        return _Value;
    }

public:
    ESet OnSet;
    EFinalize OnFinalize;

public:
    TValue() : _Value() { }
    TValue(const _Type& value) : _Value(value) { }
    TValue(const _Type& value, const ESet& set) : _Value(value), OnSet(set) { }
    ~TValue() { if (OnFinalize) OnFinalize(_Value); }

    template <typename T>
    inline _Type operator+(const T& value) { return _Value + value; }
    inline _Type operator+(const _Type& value) { return _Value + value; }
    inline _Type operator+(const TValue<_Type>& value) { return _Value + value._Value; }
    inline _Type operator-(long value) { return _Value - value; }
    template <typename T>
    inline _Type operator-(const T& value) { return _Value - value; }
    inline _Type operator-(const _Type& value) { return _Value - value; }
    inline _Type operator-(const TValue<_Type>& value) { return _Value - value._Value; }
    template <typename T>
    inline _Type operator*(const T& value) { return _Value * value; }
    inline _Type operator*(const _Type& value) { return _Value * value; }
    inline _Type operator*(const TValue<_Type>& value) { return _Value * value._Value; }
    template <typename T>
    inline _Type operator/(const T& value) { return _Value / value; }
    inline _Type operator/(const _Type& value) { return _Value / value; }
    inline _Type operator/(const TValue<_Type>& value) { return _Value / value._Value; }
    template <typename T>
    inline _Type operator%(const T& value) { return _Value % value; }
    inline _Type operator%(const _Type& value) { return _Value % value; }
    inline _Type operator%(const TValue<_Type>& value) { return _Value % value._Value; }

    template <typename T>
    inline _Type& operator=(const T& value) { return _Set(value); }
    inline _Type& operator=(const _Type& value) { return _Set(value); }
    inline _Type& operator=(const TValue<_Type>& value) { return _Set(value._Value); }
    inline _Type& operator++() { return _Set2(); }
    inline _Type operator++(int) { return _Set2(); }
    inline _Type& operator--() { return _Set3(); }
    inline _Type operator--(int) { return _Set3(); }
    template <typename T>
    inline _Type& operator+=(const T& value) { return _Set4(value); }
    inline _Type& operator+=(const _Type& value) { return _Set4(value); }
    inline _Type& operator+=(const TValue<_Type>& value) { return _Set4(value._Value); }
    template <typename T>
    inline _Type& operator-=(const T& value) { return _Set5(value); }
    inline _Type& operator-=(const _Type& value) { return _Set5(value); }
    inline _Type& operator-=(const TValue<_Type>& value) { return _Set5(value._Value); }
    template <typename T>
    inline _Type& operator*=(const T& value) { return _Set6(value); }
    inline _Type& operator*=(const _Type& value) { return _Set6(value); }
    inline _Type& operator*=(const TValue<_Type>& value) { return _Set6(value._Value); }
    template <typename T>
    inline _Type& operator/=(const T& value) { return _Set7(value); }
    inline _Type& operator/=(const _Type& value) { return _Set7(value); }
    inline _Type& operator/=(const TValue<_Type>& value) { return _Set7(value._Value); }
    template <typename T>
    inline _Type& operator%=(const T& value) { return _Set8(value); }
    inline _Type& operator%=(const _Type& value) { return _Set8(value); }
    inline _Type& operator%=(const TValue<_Type>& value) { return _Set8(value._Value); }
    template <typename T>
    inline _Type& operator&=(const T& value) { return _Set9(value); }
    inline _Type& operator&=(const _Type& value) { return _Set9(value); }
    inline _Type& operator&=(const TValue<_Type>& value) { return _Set9(value._Value); }
    template <typename T>
    inline _Type& operator|=(const T& value) { return _Set10(value); }
    inline _Type& operator|=(const _Type& value) { return _Set10(value); }
    inline _Type& operator|=(const TValue<_Type>& value) { return _Set10(value._Value); }
    template <typename T>
    inline _Type& operator^=(const T& value) { return _Set11(value); }
    inline _Type& operator^=(const _Type& value) { return _Set1(value); }
    inline _Type& operator^=(const TValue<_Type>& value) { return _Set11(value._Value); }

    template <typename T>
    inline bool operator==(const T& value) { return _Value == value; }
    inline bool operator==(const _Type& value) { return _Value == value; }
    inline bool operator==(const TValue<_Type>& value) { return _Value == value._Value; }
    template <typename T>
    inline bool operator!=(const T& value) { return _Value != value; }
    inline bool operator!=(const _Type& value) { return _Value != value; }
    inline bool operator!=(const TValue<_Type>& value) { return _Value != value._Value; }
    template <typename T>
    inline bool operator>(const T& value) { return _Value > value; }
    inline bool operator>(const _Type& value) { return _Value > value; }
    inline bool operator>(const TValue<_Type>& value) { return _Value > value; }
    template <typename T>
    inline bool operator<(const T& value) { return _Value < value; }
    inline bool operator<(const _Type& value) { return _Value < value; }
    inline bool operator<(const TValue<_Type>& value) { return _Value < value._Value; }
    template <typename T>
    inline bool operator>=(const T& value) { return _Value >= value; }
    inline bool operator>=(const _Type& value) { return _Value >= value; }
    inline bool operator>=(const TValue<_Type>& value) { return _Value >= value._Value; }
    template <typename T>
    inline bool operator<=(const T& value) { return _Value <= value; }
    inline bool operator<=(const _Type& value) { return _Value <= value; }
    inline bool operator<=(const TValue<_Type>& value) { return _Value <= value._Value; }

    template <typename T>
    inline _Type operator&(const T& value) { return _Value & value; }
    inline _Type operator&(const _Type& value) { return _Value & value; }
    inline _Type operator&(const TValue<_Type>& value) { return _Value & value._Value; }
    template <typename T>
    inline _Type operator^(const T& value) { return _Value ^ value; }
    inline _Type operator^(const _Type& value) { return _Value ^ value; }
    inline _Type operator^(const TValue<_Type>& value) { return _Value ^ value._Value; }
    template <typename T>
    inline _Type operator|(const T& value) { return _Value | value; }
    inline _Type operator|(const _Type& value) { return _Value | value; }
    inline _Type operator|(const TValue<_Type>& value) { return _Value | value._Value; }
    inline _Type operator~() { return ~_Value; }

    inline bool operator!() { return !_Value; }
    template <typename T>
    inline _Type operator&&(const T& value) { return _Value && value; }
    inline _Type operator&&(const _Type& value) { return _Value && value; }
    inline _Type operator&&(const TValue<_Type>& value) { return _Value && value._Value; }
    template <typename T>
    inline _Type operator||(const T& value) { return _Value || value; }
    inline _Type operator||(const _Type& value) { return _Value || value; }
    inline _Type operator||(const TValue<_Type>& value) { return _Value || value._Value; }

    inline _Type& operator()() { return _Value; }
    inline _Type& operator()() const { return _Value; }
    inline operator _Type() { return _Value; }
    inline operator _Type() const { return _Value; }
};

Здравствуйте, jazzer, Вы писали:

J>По мотивам эпохального топика "С — зло...

" http://www.rsdn.ru/forum/cpp.applied/4109801.1.aspx

Говногод как и хороший код можно написать практически на любом языке. Все дело в программисте, а не в языке.

От:	jazzer	Skype: enerjazzer
Дата:	14.01.11 08:27
Оценка:	10 (5)

От:	sof.bix	http://byterix.net
Дата:	14.01.11 09:07
Оценка:

От:	jazzer	Skype: enerjazzer
Дата:	14.01.11 09:15
Оценка:	1 (1) +2

От:	sof.bix	http://byterix.net
Дата:	14.01.11 09:21
Оценка:

От:	jazzer	Skype: enerjazzer
Дата:	14.01.11 09:24
Оценка: