создать ресурс №1.
использовать ресурс №1.
проверить условие.
создать ресурс №2.
использовать ресурс №2.
проверить условие.
создать ресурс №3.
использовать ресурс №3.
проверить условие.
создать ресурс №4.
использовать ресурс №4.
проверить условие.

class A
{
...
    int operator+(int);        //оператор сложения A+int
...
}

class A
{
...
    int opAdd(int);        //оператор сложения A+int - функция со "специальным" именем opAdd
...
}

A a;
double d = 1/a;     //как написать кастомный оператор для этого случая?

class A
{
...
};

double operator/(int, A&);

class A
{
    double opDiv_r(int, A&);    //opDiv + _r (right)
};

//C++
A a, b;
if(a == b)    ...            //вызов A.operator==
if(a != b)    ...            //вызов A.operator!=

//D
A a, b;
if(a == b)    ...            //вызов A.opEquals
if(a != b)    ...            //вызов !A.opEquals

//C++
A a, b;
if(a > b)    ...            //вызов A.operator>
if(a < b)    ...            //вызов A.operator<
//...и т.д.

//D
A a, b;
if(a <  b)    ...            //вызов A.opCmp(b) <  0
if(a >  b)    ...            //вызов A.opCmp(b) >  0
if(a <= b)    ...            //вызов A.opCmp(b) <= 0
if(a >= b)    ...            //вызов A.opCmp(b) >= 0

IT>Хочешь со мной пообщаться в подобном стиле? Можно конечно было бы задвинуть что-нибудь типа "Вам бы, уважаемый, сначала калькулятором научиться пользоваться, а уже потом рассуждать о программировании..", но мне это уже давно не интересно. Да и бывает что в баню я за это отправляю, придётся потом самого себя банить. Так что давай оставим другим сарказм, сатиру и юмор, переходящие в неуклюжие упражнения в демагогии. Ok?

При увеличении числа одновременно живущих объектов ещё на порядок ситуация стала ещё более печальной для GC. Теперь выигрыш заканчивается на 75 байтах, и далее GC начинает отставать, проигрывая в десятки раз, а при размере объектов в 5000 байт GC вообще впал в анабиоз часа на три, в то время как хипы уверенно справились с задачей за несколько минут.

... we execute a range of unaltered
Java benchmarks using both garbage collection and explicit
memory management. Comparing runtime, space consumption,
and virtual memory footprints, we find that when space is plentiful,
the runtime performance of garbage collection can be competitive
with explicit memory management, and can even outperform
it by up to 4%. We find that copying garbage collection can
require six times the physical memory as the Lea or Kingsley allocators
to provide comparable performance. We also show that garbage
collection suffers orders-of-magnitude performance penalties
when paging occurs. This first-ever comparison of explicit memory
management and copying garbage collection shows where garbage
collectionmust improve in the future. While we expect the incorporation
of L3 caches to minimize the impact of garbage collection’s
poor L2 locality, the relative cost of disk latency continues to grow.
Improving the space efficiency and page-level locality of garbage
collection will thus become increasingly important.

IT>Мда... Хип и GC — это две принципиально разные вещи. Как можно скрестить бульдога с носорогом и получить в результате белого лебедя я совершенно не понимаю Объясни мне убогому.

IT>Только не забудь упомянуть про цену такого решения

CS>>И вот там, в этой золотой середине, и сидит D

IT>И что это даст? Добавление в результате ещё одного менеджера менеджеров памяти?

IT>А вообще, котята такие — мне не нравится, что вместо доказательств в защиту D ты всё время скатываешься на поиск недостатков в .NET. Странная манера. Мы же в этом топике не .NET обсуждаем, правда? Но если тебе хочется, давай исходить из того, что .NET плохой, даже очень плохой, можешь больше не пытаться мне это доказать. Лучше докажи, что D хороший. Если получится, то кто знает, может потом вместе доказывать будем

byte[100] array; // будут инициализированны по умолчанию.

void foo(out int bar)
{
}
    int bar = 3;
    foo(bar);
//    bar is now 0

E>class    Compound_Key
E>{
E>    int    opCmp( Compound_Key o )
E>    {
E>        if( a_ < o.a_ || ( a_ == o.a_ && b_ < o.b_ ) )
E>            return -1;
E>        // Оптимистично предполагаем, что всегда будет использоваться (c1<c2).
E>        return 0;
E>    }
E>};
E>

class    Compound_Key
{
    int    opCmp( Compound_Key o )
    { int Result;
        Result =a_.opCmp(o.a_);
        if (Result!=0) return Result;
        Result =b_.opCmp(o.b_);
        if (Result!=0) return Result; // и продолжить столько раз, сколько полей
        Result =c_.opCmp(o.c_);
        return Result;
    }
};

E>>>Зря он так предполагает

E>Да, я тоже хотел об этом сказать. Но поскольку в исходном сообщении ЗХ не было упомянута директива #line, то решил об этом не говорить. К тому же, при желании, кодогенераторы могут сами подсчитывать номера строк в генерируемом коде Хоть это и геморройно.

Special Tokens
These tokens are replaced with other tokens according to the following table:
Special Token Replaced with...
__FILE__ string literal containing source file name
__LINE__ integer literal of the current source line number
__DATE__ string literal of the date of compilation "mmm dd yyyy"
__TIME__ string literal of the time of compilation "hh:mm:ss"
__TIMESTAMP__ string literal of the date and time of compilation "www mmm dd hh:mm:ss yyyy"

module mymodule;    //этого можно не писать. тогда имя модуля совпадет с именем файла, в котором содержится модуль
//еще можно так:
module mypackage.mysabpackage.mymodule;    //логическая группировка модулей в "пакеты"

import mymodule;
import mypackage.mysabpackage.mymodule;

version(UNICODE)    //символ, переданный в качестве ключа компилятору
{
 ....
}
else
{
 ....
}

version(Debug)
{
...куча дебужного коду...
}

static assert(int.sizeof >= 4);

//однострочный комментарий - как в С++
/*
многострочный комментарии - тоже как в С++
*/

/+
вложенный комментарий - вот такого С++ не умеет ;)
 /+
   это вложено
 +/
тут - все еще комментарий
+/

//C++
123456789.123456789       //сколько-сколько?

//D
123_456_789.123_456_789   //внутренние подчеркивания игнорируются

//C++
//модификаторы доступа:
class A
{
public:
//ниже пошли паблики
....

private:
//ниже пошли приваты
....
}

static int boo();

const int a;

//D - свобода выбора======================

class A
{
public:
//ниже пошли паблики
....

protected int foo();    //protected относится только к этой функции

    private
    {
       //private относится ко всему, что в этом блоке
      ....
    }
}

static int boo();//одна статическая функция

static
{
//блок статических функций
}

static:
//все, ниже пошли статики...

//с const и вообще всеми модификаторами - аналогичная фигня:

const int a;

const
{
//куча констант
}

const:
//дальше все нафик константное

//Выравнивание:
align(1) char some_byte;
align(4)
{
    //all here is aligned by 4
}

//deprecated:
deprecated
{
    int foo();
    void boo();
    
/*
  таким аттрибутом можно пометить части библиотеки, которые могут быть
  удалены в следующих релизах. Реакция на этот аттрибут зависит от оп-
  ций компилятора. Его можно настроить так, чтобы он выдавал предупре-
  ждение, ошибку или молчал на использование deprecated фич.
*/
}

//override
class A
{
   override int foo(); //эта функция обязана быть у моего предка (я хочу заместить функцию предка.
                       //если ее там нет или у нее другой набор параметров - это ошибка
}

kaboom:
for(...)
{
    while(...)
    {
        do
        {
            break kaboom;
        }while(...)
        continue kaboom;
    }
}

//Гарантируется, что вот такой массив:
int[3][6] Matrix;
//- то есть статический массив статических массивов
//хранится в памяти как матрица, то есть все значения идут подряд.

//C++:
char path[] = "c:\\My documents\\something\\else"; //not good
char regex[]= "[^\\\\]*(\\\\.[^\\\\]*)*";       //brrrrrrrr!

//D:
char path[] = r"c:\My documents\something\else"; //:)
char regex[]= `[^\\]*(\\.[^\\]*)*`;              //another way :)

//Инициализация структур:
struct S
{
   int a;
   char b;
   float f;
}

S s = {5, 'a', 0.3}; //можно - как в С++
S s = {b:'a'};       //явная инициализация члена b, остальные проинициализируются по умолчанию

//Инициализация массивов:
int[10] arr1 = {0,1,2,3,4,5,6,7,8,9};    //как в С++

int[10] arr2 = {1:18, 6:10, 9:-1};       //теперь содержимое arr2 == {0, 18, 0, 0, 0, 0, 10, 0, 0 ,-1}

ЗХ>//D
ЗХ>A a, b;
ЗХ>if(a == b)    ...            //вызов A.opEquals
ЗХ>if(a != b)    ...            //вызов !A.opEquals
ЗХ>

int opCmp(T a, T b) 
{ 
   if(a < b) return -1;
   if(a > b) return 1;
   return 0;
}

typedef uint Color; 
Color c; 
c += 28; // ошибка компиляции.

alias int myint; // это то что в C++ typedef.

E>Вообще-то я не думаю, что сравнение объектов, которые используются в качестве ключа map-а бессмыслено. Ведь в std::map ключи элементов как раз-таки сравниваются

...
E>    int    opCmp( Compound_Key o )
E>    {
E>        if( a_ < o.a_ || ( a_ == o.a_ && b_ < o.b_ ) )
E>            return -1;
E>        // Оптимистично предполагаем, что всегда будет использоваться (c1<c2).
E>        return 0;
E>    }
...

class Task
{
    private int priority;
    public int opCmp(Task t)
    {
        return priority - t.priority;
    }
}

C>void foo(out int bar)
C>{
C>}
C>    int bar = 3;
C>    foo(bar);
C>//    bar is now 0

    //======================================================comp_op_table_rgba
    template<class ColorT, class Order> struct comp_op_table_rgba
    {
        typedef typename ColorT::value_type value_type;
        typedef void (*comp_op_func_type)(value_type* p, 
                                          unsigned cr, 
                                          unsigned cg, 
                                          unsigned cb,
                                          unsigned alpha);
        static comp_op_func_type g_comp_op_func[];
    };

    //==========================================================g_comp_op_func
    template<class ColorT, class Order> 
    typename comp_op_table_rgba<ColorT, Order>::comp_op_func_type
    comp_op_table_rgba<ColorT, Order>::g_comp_op_func[] = 
    {
        comp_op_rgba_clear<ColorT,Order>::blend_pix,
        . . .
    };

СГ>Странно, а какая связь между вирутальными (абстрактными) конструкторами (с которых началаясь эта ветка форума) и умными указателями . Я всегда думал, что умные указатели растут из templates + автоматический вызов деструкторов при выходе из блока.

lock.acquire(obj);

lock.aquire(obj);
...
lock.release(); // do not forget!

{
  Lock lock(obj);
  ...
  // free your mind!
}

try
   res.acquire();
   obj.explode(random(2)); // рванёт - не рванёт
finally
   res.release(); // do not forget!
end;

{
   ResGuard guard(res);
   obj.explode(random(2));
   // free your mind and be happy.
}

FR>>У меня прямо дежавю какое то, все как в питоне

ЗХ>забавно а как это там выглядит?

__add__(self, other)
__sub__(self, other)
__mul__(self, other)
__div__(self, other)
__mod__(self, other)
__divmod__(self, other)
__pow__(self, other [, modulo])
__lshift__(self, other)
__rshift__(self, other)
__and__(self, other)
__xor__(self, other)
__or__(self, other)

A mixin has its own scope, even if a declaration is overridden by the enclosing one:

        int x = 4;

    template Foo()
    {
        int x = 5;
        int bar() { return x; }
    }

    mixin Foo;

    void test()
    {
        printf("x = %d\n", x);        // prints 4
        printf("bar() = %d\n", bar());    // prints 5
    }

MS>"Все кому не лень" делают это по одной простой причине — в языках имеется тип "строка". В C++ такого типа не существует. Следовательно, switch/case по строке невозможен по причине отсутствия самой строки.

MS>class Key
MS>{
MS>   Key(int i, string s);
MS>   . . .
MS>   bool operator < (const Key&) ...
MS>};


MS>. . .

MS>switch(Key(i, s))
MS>{
MS>   case Key(1, "123"):
MS>   case Key(1, "124"):
MS>   . . .
MS>}
MS>

class Key : IComparable
{
  Key(int i, string s);
  . . .
  override GetHashCode()...
    IComparable.CompareTo(...)...
};

Dictionary<Key, Handler> _map = Dictionary<Key, Handler>();

void Init()
{
    _map[new Key(1, "124")] = delegate { ... };
    _map[new Key(1, "123")] = delegate { ... };
}

void Test(Key key)
{
    _map[key]();
}

struct Mul
 {
  int hi;
  unsigned low;
    
  Mul(int a,int b);
 };

class ArrayList { 
  void Insert(int index , object value)
     requires 0 <= index && index <= Count otherwise ArgumentOutOfRangeException;
     requires !IsReadOnly && !IsFixedSize otherwise NotSupportedException;
  { 
    ....    
  }

Date d(2005,05,05);
label qn[] = { q1=0, q2=1, q3=2, q4=2 };
swtitch(d.quarter(), qn)
{
   default: . . .
   q1: . . .
   q2: . . .
   q3: . . .
   q4: . . .
};

//Это - С++:
class A
{
    int val();                //getter
    int val(int _newval);    //setter (собака такая - сеттер)
}

A a;
int i = a.val();
a.val(i);

//==============================
//А вот это - уже D:
class A
{
    int val();                //getter
    int val(int _newval);    //setter
}

A a;
int i = a.val;    //вызывается A.val();
a.val = i;        //вызывается A.val(int);

int[] arr;        //что написано, то и есть - это динамический массив int'ов

for(int i = 0; i < arr.length; ++i)        //использование свойства массива .length

a.length = 42;                            //еще одно использование свойства

int maxint  = int.max;  //максимальное значение int'а
int sizeint = int.size;    //эта фенечка вместо С-шного sizeof(int)

float.nan                //NaN
float.infinity            //бесканечнасть

(2).max                    //эквивалентно int.max
2.max                    //ошибка - у числа 2 нету свойствов

int val = int.init;        //получим 0
int a;
val = a.init;            //получим 0 - потому что a было проинициализировано нулем

int b = 8;
val = b.init;            //получим 8

typedef int mycoolint = 2;
val = mycoolint.init;    //получим 2
mycoolint c;
val = c.init;            //получим 2

For a native multiprocessor operating system, Aos is small, with a kernel of 7,210 lines of source or about 50KB of object code. For comparison, the 4.4BSD kernel (cf. 8.1.2) consists of 58,289 lines of C code (excluding file systems, network protocols and device drivers, which add another 143,962 lines) [65]. Version 2.4 of the Linux kernel consists of approximately 420,000 lines of C code (excluding drivers, file systems and architecture-specific code, which bring the total to 2.4 million lines) [128], and has a minimum size of around 500KB on Intel processors. Microsoft boasts that Windows 2000 “consists of over 29 million lines of code”, but does not say what is included in this figure, so it is not possible to compare specifics.

Subsystem        Lines

Kernel            7210
Service support   2532
File system       4624
User interface    2204
Network           6200
Oberon for Aos    8667

Total            31437

class Task
{
    static const MaxPriority = // ...;
    static const MinPriority = // ...;

    public this(int priority_)
    {
        priority = priority_;
    }

    public opCmp(Task t)
    {
        priority - t.priority;
    }

    invariant
    {
        assert((priority >= MinPriority) && (priority <= MaxPriority));
    }

    private int priority;
}

std::pair<int,int> divmod(int a, int b)
{
    std::make_pair(a / b, a % b);
}

divmod a b = (a / b, a % b)

divmod(a,b) { (a / b, a % b) }

template <class T>
std::pair<T,T> divmod(T a, T b)
{
    std::make_pair(a / b, a % b);
}

int cmp(A a, A b)
{
  int c;
  c = cmp(a.x, b.x); if(c) return c;
  c = cmp(a.y, b.y); if(c) return c;
  ...
  return 0;
}

bool less(A a, A b)
{
  if(less(a.x, b.x)) return true; if(less(b.x, a.x)) return false;
  if(less(a.y, b.y)) return true; if(less(b.y, a.y)) return false;
  ...
  return false;
}

L& operator += (      L& lhs, const R& rhs) { lhs = lhs + rhs;         return lhs; }
L  operator +  (const L& lhs, const R& rhs) { L res = lhs; res += rhs; return res; }

MS>Date d(2005,05,05);
MS>label qn[] = { q1=0, q2=1, q3=2, q4=2 };
MS>swtitch(d.quarter(), qn)
MS>{
MS>   default: . . .
MS>   q1: . . .
MS>   q2: . . .
MS>   q3: . . .
MS>   q4: . . .
MS>};
MS>

MS>Фактически, switch это и есть вычисляемый goto, но только кастрированный и неспособный к развитию И при этом — не гарантирующий какую-либо оптимизацию. Все, что можно гарантировать — это O(N) и не более того. В то время, как вычисляемый goto железно обеспечивает O(1).

switch( d.quarter() ) 
 {
  case 1 : ... break;
  case 2 : ... break;
  ...
  default: ...
 }

ЗХ>//C++
ЗХ>A a, b;
ЗХ>if(a > b)    ...            //вызов A.operator>
ЗХ>if(a < b)    ...            //вызов A.operator<
ЗХ>//...и т.д.

ЗХ>//D
ЗХ>A a, b;
ЗХ>if(a <  b)    ...            //вызов A.opCmp(b) <  0
ЗХ>if(a >  b)    ...            //вызов A.opCmp(b) >  0
ЗХ>if(a <= b)    ...            //вызов A.opCmp(b) <= 0
ЗХ>if(a >= b)    ...            //вызов A.opCmp(b) >= 0
ЗХ>

struct    Compound_Key
{
    Some_Key_Type    a_;
    Another_Key_Type    b_;
};

bool operator( const Compound_Key & o ) const
    {
        return ( a_ < o.a_ || ( a_ == o.a_ && b_ < o.b_ ) );
    }

ЗХ>//C++
ЗХ>A a, b;
ЗХ>if(a > b)    ...            //вызов A.operator>
ЗХ>if(a < b)    ...            //вызов A.operator<
ЗХ>//...и т.д.

ЗХ>//D
ЗХ>A a, b;
ЗХ>if(a <  b)    ...            //вызов A.opCmp(b) <  0
ЗХ>if(a >  b)    ...            //вызов A.opCmp(b) >  0
ЗХ>if(a <= b)    ...            //вызов A.opCmp(b) <= 0
ЗХ>if(a >= b)    ...            //вызов A.opCmp(b) >= 0
ЗХ>

bool operator < (Some const& l, Some const& r)
{
...
}
bool operator > (Some const& l, Some const& r)
{
    return r < l;
}
bool operator <= (Some const& l, Some const& r)
{
    return !(r < l);
}
bool operator >= (Some const& l, Some const& r)
{
    return !(l < r);
}

E>struct    Compound_Key
E>{
E>    Some_Key_Type    a_;
E>    Another_Key_Type    b_;
E>};
E>

Compound_Key a, b;
if(a < b) //так можно
if(a > b) //а так почему-то нельзя :(

Цель этого мне видится не в ознакомлении всего РСДНа с новым языком — а в обсуждении новых или не очень концепций D и их реализации.
(с) я.

E>>struct    Compound_Key
E>>{
E>>    Some_Key_Type    a_;
E>>    Another_Key_Type    b_;
E>>};
E>>

ЗХ>Compound_Key a, b;
ЗХ>if(a < b) //так можно
ЗХ>if(a > b) //а так почему-то нельзя :(
ЗХ>

class    Compound_Key
{
    int    opCmp( Compound_Key o )
    {
        if( a_ < o.a_ || ( a_ == o.a_ && b_ < o.b_ ) )
            return -1;
        // Оптимистично предполагаем, что всегда будет использоваться (c1<c2).
        return 0;
    }
};

CS>typedef uint Color; 
CS>Color c; 
CS>c += 28; // ошибка компиляции.
CS>

typedef Color = ....;
// или
type Color = ...;

MS>int opCmp(T a, T b) 
MS>{ 
MS>   if(a < b) return -1;
MS>   if(a > b) return 1;
MS>   return 0;
MS>}
MS>

//это - С++
//надо определить:

bool operator==(A&);
bool operator< (A&);

//сами сгенерятся:
bool operator!=(A&);    //!operator==
bool operator>=(A&);    //!operator<
bool operator<=(A&);    //operator== || operator<
bool operator> (A&);    //!operator<=

CS>>typedef uint Color; 
CS>>

LCR>typedef Color = ....;
LCR>// или
LCR>type Color = ...;
LCR>

LCR>Ы?

int c;    //переменная типа int
typedef int mycoolint;    //тип "типа" int

Dim VBAForeva As Rulezzzz;

int v = a*b/c;

v = a.muldiv(b, c);
или 
v = a.mulshift(b, 32); // - умножаем и берем старшие 32 бита

int lift = a/b;
int rem  = a%b;

ЗХ>int c;    //переменная типа int
ЗХ>typedef int mycoolint;    //тип "типа" int
ME>typedef int (*mcfp[](int (*fp)(void* v1, void* v2), int& r);
ME>struct S {....};
ME>struct _tagS {....} S1; // определение типа S1!
ME>class C {...};
ME>enum E {...};
ЗХ>

ЗХ>Dim VBAForeva As Rulezzzz;
ЗХ>

type ocaml_owns_all =
  Val of int
  | Fun of (float->string) * ocaml_owns_all;;

type mcfp = array of
(
  func * : ( (func * : (void *, void *) -> int ), void * ) -> int
);

typedef int *myarr1[];
typedef int (*myarr2)[];

CS>typedef uint Color; 
CS>Color c; 
CS>c += 28; // ошибка компиляции.
CS>

class IdealInt : public int
{
 //...
};

class Constructors: Base
{
    int a;

    this();            //конструктор всегда зовут this. Что облегчает использование паттерна проектирования copy-paste :)
    this(int i)     //как и в C++, конструкторов может быть несколько, они могут принимать параметры
    {
        a = i;        //инициализация членов - просто в теле конструктора
        this();        //в отличие от С++, конструкторы могут вызывать друг друга.
        
        super(10);    //вызов конструкторов базового класса - в любом месте конструктора. если нет явного вызова, вызовется в самом начале this(
    }
    
    int b = 18;        //инициализация членов константами
    
    ~this()            //с деструктором тоже все банально - он один, без параметров, всегда виртуальный
    {
    }
};

class A
{
    int r = random();       //так нельзя!
    
    static this()
    {
        //это выполнится до начала main 1 раз. выделение ресурсов, задание начальных значений данных членов...
        r = random();       //а вот так - можно!
    }
    
    static ~this()
    {
        //выполнится после конца main
    }
}

class Resource
{
    Resource()
    {
    /*
        открываем файлы, создаем сокеты и вообще творим всякие непотребства
    */
    }
    
    ~Resource()
    {
    //убираем за собой
    }
}

//где-то в коде:
{
    Resource r;    //взяли ресурс
    
    ....
} //ресурс освободился - даже в случае исключения

auto class Resource        //весь фокус - тут
{
    this()
    {
    /*
        открываем файлы, создаем сокеты и вообще творим всякие непотребства
    */
    }
    
    ~this()
    {
    //убираем за собой
    }
}

//где-то в коде:
{
    Resource r = new Resource;       //так авто-классы использовать нельзя
    auto Resource r =  new Resource; //только с явным указанием намерений
    
    ....
} //при выходе из scope - вызовутся деструкторы всех auto-переменных, ресурсы освободятся - даже в случае исключения