AVC>>В Си++ типизация сильнее, чем в Обероне?

AVC>>int foo(void *p)
AVC>>{
AVC>>  return ((int (*)())p)();
AVC>>}
AVC>>

union {
  void *p;
  void (*fp)();
};

#include <stdio.h>

class Float {
    float _float;
public:
    Float(float x) : _float(x) { }

    // следующая строка была закомментирована по ошибке (просто опечатка)
    //operator float() { return _float; }

    // в реальной программе bool() проверяет валидность Float
    operator bool() { return true; }
};

int main()
{
    Float F = 3.1415926536f; // Кто и шутя, и скоро пожелаетъ Пи узнать число, ужъ знаетъ.
    float x = F;
    printf("%f\n", x); // Что напечаталось? Правильно, 1.000000
    return 0;
}

Здесь надо сказать, что по сравнению с другими языками C++ имеет много недостатков, которые затрудняют разработку сложных научных программ. В частности, у него слабая поддержка одномерных и многомерных массивов, нет локальных процедур, неудачная концепция модуля, не поддерживается проверка индексов массивов, а также выполняется неконтролируемое преобразование типов.

AVC>class Float {
AVC>    float _float;
AVC>public:
AVC>    Float(float x) : _float(x) { }

AVC>    // следующая строка была закомментирована по ошибке (просто опечатка)
AVC>    //operator float() { return _float; }

AVC>    // в реальной программе bool() проверяет валидность Float
AVC>    operator bool() { return true; }
AVC>}

AVC>>    // в реальной программе bool() проверяет валидность Float
AVC>>    operator bool() { return true; }
КЕ>

КЕ> ну вы блин даете...

class Foo
{
public:
  typedef void (Foo::*some_bool)();
private:
  void some_true() {}

public:
  operator some_bool() const { if(...) return &Foo::some_true : 0; }

  ...
};

bool is_valid(double v); // проверка на NaN и Inf - встроенными средствами
bool is_valid(float v);
bool is_valid(const Float& v) { return v.is_valid(); }

while(evertrue()) { ..... }

take(semaphore, INFINITE);

from threading import *

class Orphan(Thread) :
  name = ""
  evt = 0
  def goodbye(self) :
    self.evt.set()
  def __init__(self,n) :
    Thread.__init__(self)
    self.evt = Event()
    self.name = n
  def run(self) :
    print self.name,"started"
    self.evt.wait()
    print self.name,"finished"

def fire(n) :
  t = Orphan(n)
  t.start()
  return t

# запустили...
t1 = fire("First")
t2 = fire("Second")
# отсигналили только одному
t1.goodbye()
#t2.goodbye()
# потеряли указатели
t1 = 0
t2 = 0
print "The end"

union BIGINT
{
    struct Ints
    {
        int i1,i2;
    };
    struct Bytes
   {
        byte b1,b2,b3,b4,b5,b6,b7,b8;
    };
}

>> union {
>>   void *p;
>>   void (*fp)();
>> };
>>

Несмотря на хорошую погоду, многие болельщики предпочли переждать дождь дома.

КЕ>> ну вы блин даете...

AVC>Видно, возмущение было столь сильным, что на критику уже слов не хватило?

float x;
Float X;

if(x) { ... } // если y != 0
if(X) { ... } // если x валидный? если x != 0?

if(x!=0) { ... } // предположительно, здесь компилятор может оптимизировать, увидев литеральный 0
if(X!=0) { ... } // возможно, что сравнение с целым нулём - дороже, чем просто проверка на 0

if(is_nonzero(x)) { ... } // инлайнится в y!=0
if(is_nonzero(X)) { ... } // эффективная реализация предиката - на усмотрение разработчика

if(is_valid(x)) { ... } // если такие задачи встречаются, то можно реализовать.
if(is_valid(X)) { ... } // явная замена двусмысленному operator bool