E>В общем, мне кажется, что лозунги "Нужно писать на .Net, потому, что C++ глючный, т.к. я на нем пишу с ошибками" -- это такая же эмоция, как "C++ forever!". А выбор языка и платформы для конкретной задачи должен включать в себя анализ большого количества факторов. И очень жаль, что критерий "количество багов в C++ программах" для конкретной команды оказывается на одном из первых мест.

Да нет же, все не так. Нужно писать на .Net, потому, что C++ глючный, т.к. я, все мои знакомые программисты и подавляющее большинство других программистов, на нем пишут с ошибками. (Это предложение — вообще чистой воды иллюстрация к статье "как не надо строить доказательства". — ГВ.) А количество ошибок на .net заметно меньше, как и общая скорость разработки. И практика моей компании показывает, что стоимость решений на с++ оказывается неприемлимо высокой.

- Вот все говорят о дотнете, а ведь это полная туфта. На нем же даже игрушку написать нельзя.
— Помилуйте, вот игршка. Загрузите, поглядите.
— Но на нем же даже софт-риалтайм системы невозможно создать. Причем принципияльно!
— А вы их создаете?
— Я, нет. Но все же.
— Кстати, вот сообщение о выпуске конторой ХХХ софтреалтайм-рантайма для Явы, а вот описание разработки того же самого для дотнета.
— Да? Наверно это фигня. Да и ведь не хард! Ну, тогда ЖЦ торомзит. Пример — Янус. У меня при считавании сообщений иногда тормоза. И при переключении веток тоже.
— По милйте, откройте любой профайлер и вы увидите, что ЖЦ не оказывает никакого влияния на скорость наботы Януса. Например, у меня время проведенное в ЖЦ составляет 0.02%. При открытии сообщения, Янус лезет в БД через JET, считывает строку и передает ее в IE-контрол. И JET, и IE — это анменеджед-контролы написанные на С++. Так что тормоза Януса являются чисто алгоритмическими и уж скорее могут быть ассоциированы с С++.
— А...А...А, тогда дотнет жрет очень много памяти!
— Насколько много?
— Вот янус жрет 60 метров.
— А сколько у вас ее всего?
— Гиг.
— И это вам мешает?
— Мне нет, но все же. К тому, же дотнет интерпретатор, вот поглядите как в янусе переключаются сообщения.
— Помилуйте, дотнет джитер.
— Да какая разница?
— Дык, он порождает компилированный код который мало чем отличается от порождаемого средним С++-компилятором.
— А...а...а, вот еще у дотнета есть куча рантайм-проверок.
— Да есть, но она делаются не всегда и часто оптимизируются. В итоге сумма оверхэда и отсотвания оптимизатора редко позволяет С++-коду обогнать управляемый больше чем на 20%. Плюс к тому же всегда есть возможность при крайней необходимости воспользоваться небезопасным кодом и породить такой же кода как на С++/С.
— А какой же тогда смысл в C#?
— Дык, оптимизировать нужно очень малый объем кода. А остальной при этом пишется проще и быстрее.
— Нифига не проще!
— Да, как же не проще? Я вот писал на С++ и после перехода на дотнет и C# по пошествию некоторого времени начал работать намного продуктивнее.
— А мой опыт показывает, что нифига на C# писать не быстрее.
— А вы пробовали.
— Да! Я попробовал писать на C# "Дарова, мир!", поплювался на непривычных синтаксис и бросил.

MyRAII1 r1;
MyRAII1 r2;
MyRAII1 r3;
MyRAII1 r4;

С++ — статический язык, со статической типизацией, потому что С++ программы зачастую пишуться, что бы выполняться без присутствия программиста.

> V>using (MyRAII1 r1 = new MyRAII1())
> V>    using (MyRAII2 r2 = new MyRAII2())
> V>        using (MyRAII3 r3 = new MyRAII3())
> V>            using (MyRAII4 r4 = new MyRAII4()) {
> V>                ...
> V>                ...
> V>            }
> V>

> using (MyRAII1 r1 = new MyRAII1())
> using (MyRAII2 r2 = new MyRAII2())
> using (MyRAII3 r3 = new MyRAII3())
> using (MyRAII4 r4 = new MyRAII4())
> {
>     ...
>     ...
> }
>

> {
>     MyRAII1 r1 = MyRAII1();
>     MyRAII2 r2 = MyRAII2();
>     MyRAII3 r3 = MyRAII3();
>     MyRAII4 r4 = MyRAII4();
>     {
>         ...
>         ...
>     }
> }
>

{
    MyRAII1 r1;
    MyRAII2 r2;
    MyRAII3 r3;
    MyRAII4 r4;
    ...
}

In computer science, a dynamic programming language is a kind of programming language in which programs can change their structure as they run: functions may be introduced or removed, new classes of objects may be created, new modules may appear.

K>>struct Triangle
K>>{
K>>   Node *nodes[3];
K>>   Node* node_at( int idx ) // кольцевой доступ
K>>   {
K>>      static const int imap[] = { 1, 2, 0, 1, 2, 0, 1 };
K>>      return nodes[imap[idx+2]];
K>>   }
K>>};
K>>

struct Shell; // устоявшийся, редко меняемый класс

void shell_make_watertight(Shell *p, double tolerance); // непрерывно в разработке
// и еще куча функций вокруг, которые добавляются-выбрасываются в процессе

class Shell
{
 // триста функций на борту
};

Node* node_at(int idx)
{
   switch (idx)
   {
     case -2: return &node1;
     case -1: return &node2;
     case  0: return &node0;
     case  1: return &node1;
     case  2: return &node2;
     case  3: return &node0;
     case  4: return &node1;
   }
}

Назову конкретные цифры: 150, 8, 50, 15, 2150000...

K>class Triangle
K>{
K>   public Node A, B, C; // вместо массива переменные
K>}
K>

using System;
using System.Collections.Generic;
using System.Collections;

class Triangle : ICollection<Node>
{
    public Triangle(Node node1, Node node2, Node node3)
    {
        Node1 = node1;
        Node2 = node2;
        Node3 = node3;
    }

    public Node Node1;
    public Node Node2;
    public Node Node3;

    public IEnumerator<Node> Nodes
    {
        get
        {
            yield return Node1;
            yield return Node2;
            yield return Node3;
        }
    }

    public Node[] ToArray()
    {
        return new Node[] { Node1, Node2, Node3 };
    }

    #region ICollection<Node> Members

    public Node this[int index]
    {
        get
        {
            switch (index)
            {
                case 0:  return Node1;
                case 1:  return Node2;
                case 2:  return Node3;
                default: throw new ArgumentOutOfRangeException("index");
            }
        }
    }

    public bool Contains(Node item)
    {
        return item == Node1 || item == Node2 || item == Node3;
    }

    public void CopyTo(Node[] array, int arrayIndex) { array[0] = Node1; }
    public int Count { get { return 3; } }
    public bool IsReadOnly { get { return true; } }
    public IEnumerator<Node> GetEnumerator() { return Nodes; }
    IEnumerator IEnumerable.GetEnumerator() { return Nodes; }

    public void Add(Node item) { throw new InvalidOperationException(); }
    public void Clear() { throw new InvalidOperationException(); }
    public bool Remove(Node item) { throw new InvalidOperationException(); }

    #endregion
}

struct Node
{
    public Node(double x, double y) { X = x; Y = y; }
    public double X;
    public double Y;

    public static bool operator ==(Node a, Node b)
    {
        return a.X == b.X && a.Y == b.Y;
    }

    public static bool operator !=(Node a, Node b)
    {
        return a.X != b.X || a.Y != b.Y;
    }

    public override bool Equals(object obj)
    {
        if (obj == null || !(obj is Node))
            return false;
        
        return this == (Node)obj;
    }

    public override int GetHashCode()
    {
        return (int)(X * 1000) ^ (int)(Y * 10000);
    }

    public override string ToString()
    {
        return "{ X=" + X + " Y=" + Y + " }";
    }
}

    class Program
    {
        static void Main()
        {
            Triangle triangle1 = new Triangle(new Node(1.123, 2.345),
                new Node(0.123, 0.345), new Node(2.123, 3.345));

            foreach (Node node in triangle1)
                Console.Write(node + " ");

            Console.WriteLine();
            Console.WriteLine();

            Console.WriteLine("triangle1[1]    = " + triangle1[1]);
            Console.WriteLine("triangle1.Node2 = " + triangle1.Node2);
        }
    }

capacity: 100000, iterations: 1000
get_via_static_imap duration: 13.75
get_via_local_imap duration: 20.453
get_via_mod duration: 21.203

capacity: 100000, iterations: 100
get_via_static_imap duration: 1.344
get_via_local_imap duration: 2.046
get_via_mod duration: 2.11

capacity: 100, iterations: 100000
get_via_static_imap duration: 1.203
get_via_local_imap duration: 1.907
get_via_mod duration: 1.968

capacity: 1000, iterations: 10000
get_via_static_imap duration: 1.281
get_via_local_imap duration: 1.922
get_via_mod duration: 2.015

capacity: 10000, iterations: 1000
get_via_static_imap duration: 1.187
get_via_local_imap duration: 1.906
get_via_mod duration: 2

#include <iostream>
#include <string>
#include <vector>
#include <ctime>
#include <cmath>
#include <cstdio>

using namespace std;

class node_t
    {
    private :
        double m_x;
        double m_y;

    public :
        node_t() : m_x( 0 ), m_y( 0 ) {}

        double x() const { return m_x; }
        double y() const { return m_y; }
    };

class triangle_t
    {
    private :
        node_t *    m_nodes[ 3 ];

        static const int imap( int idx )
            {
                static const int m[] = { 1, 2, 0, 1, 2, 0, 1 };
                return m[ idx ];
            }
    public :
        triangle_t( node_t * a, node_t * b, node_t * c )
            {
                m_nodes[ 0 ] = a;
                m_nodes[ 1 ] = b;
                m_nodes[ 2 ] = c;
            }

        const node_t * get_via_static_imap( int idx ) const
            {
                return m_nodes[ imap( idx + 2 ) ];
            }

        const node_t * get_via_local_imap( int idx ) const
            {
                const int m[] = { 1, 2, 0, 1, 2, 0, 1 };
                return m_nodes[ m[ idx + 2 ] ];
            }

        const node_t * get_via_mod( int idx ) const
            {
                return m_nodes[ ( idx + 2 ) % 3 ];
            }
    };

typedef const node_t * (triangle_t:: *pfn_accessor_t)( int idx ) const;

typedef std::vector< node_t > nodes_t;
typedef std::vector< triangle_t > triangles_t;
typedef std::vector< double > results_t;

double
calculate( const triangle_t & t, pfn_accessor_t accessor )
    {
        // Тут какая-то имитация математики.
        return pow( (t.*accessor)( -1 )->x() - (t.*accessor)( 0 )->x(), 2 ) +
            pow( (t.*accessor)( 0 )->x() - (t.*accessor)( 1 )->x(), 2 ) +
            pow( (t.*accessor)( -1 )->y() - (t.*accessor)( 0 )->y(), 2 ) +
            pow( (t.*accessor)( 0 )->y() - (t.*accessor)( 1 )->y(), 2 );
    }

void
meter(
    const std::string & test_case_name,
    const unsigned int iterations,
    const triangles_t & triangles,
    results_t & results,
    pfn_accessor_t accessor )
    {
        std::cout << test_case_name << " " << std::flush;

        std::clock_t start = std::clock();

        for( unsigned int i = 0; i != iterations; ++i )
            {
                for( unsigned int j = 0, j_max = triangles.size();
                        j != j_max; ++j )
                    results[ j ] = calculate( triangles[ j ], accessor );
            }

        std::clock_t finish = std::clock();

        std::cout << "duration: "
                << double( finish - start ) / CLOCKS_PER_SEC
                << std::endl;
    }

void
determine_capacities( int argc, char ** argv,
    unsigned int & capacity,
    unsigned int & iterations )
    {
        const unsigned int default_capacity = 100000;
        const unsigned int default_iterations = 1000;

        capacity = default_capacity;
        iterations = default_iterations;

        if( 3 == argc )
            {
                unsigned int t1, t2;
                if( 1 == sscanf( argv[ 1 ], "%u", &t1 ) &&
                        1 == sscanf( argv[ 2 ], "%u", &t2 ) )
                    {
                        capacity = t1;
                        iterations = t2;
                    }
                else
                    std::cerr << "arguments (" << argv[ 1 ]
                            << ", " << argv[ 2 ] << ") ignored" << std::endl;
            }

        std::cout << "capacity: " << capacity << ", iterations: "
                << iterations << std::endl;
    }

int main( int argc, char ** argv ) 
    { 
        unsigned int capacity;
        unsigned int iterations;
        determine_capacities( argc, argv, capacity, iterations );

        nodes_t nodes( capacity * 3 );
        triangles_t triangles;
        triangles.reserve( capacity );

        results_t results( capacity );

        for( unsigned int i = 0; i != capacity; ++i )
            triangles.push_back(
                    triangle_t(
                            &nodes[ i * 3 ],
                            &nodes[ i * 3 + 1 ],
                            &nodes[ i * 3 + 2 ] ) );

        meter( "get_via_static_imap", iterations, triangles, results,
                &triangle_t::get_via_static_imap );

        meter( "get_via_local_imap", iterations, triangles, results,
                &triangle_t::get_via_local_imap );

        meter( "get_via_mod", iterations, triangles, results,
                &triangle_t::get_via_mod );
    }

struct CSharpTriangle
{
  public fixed Node nodes[3];
}

K>>class CSharpTriangle
K>>{
K>>  public Node[] nodes = new Node[3]; // все приехали, можете закрывать свою лавочку
K>>}
K>>

struct Triangle
{
   Node  *nodes[3];
};

class Triangle
{
   public Node A, B, C; // вместо массива переменные
}

Node* node_at( int idx )
{
   static const int imap[] = { 1, 2, 0, 1, 2, 0, 1 };
   return nodes[imap[idx+2]]; // транслируем колецевой индекс в обычный
}
// юзается очень удобно, пример вычисление всех углов:
void angles(Triangle &t)
{
   double angs[3];
   for ( int i = 0; i < 3; i++ )
      angs[i] = angle( t.node_at(i-1), t.node_at(i), t.node_at(i+1) );
    
}

class CSharpTriangle
{
  public Node[] nodes = new Node[3]; // все приехали, можете закрывать свою лавочку
}

?get_via_static_imap@triangle_t@@QBEPBVnode_t@@H@Z PROC NEAR ; triangle_t::get_via_static_imap, COMDAT
; _this$ = ecx

; 45   :                 return m_nodes[ imap( idx + 2 ) ];

    mov    eax, DWORD PTR _idx$[esp-4]
    mov    edx, DWORD PTR ?m@?1??imap@triangle_t@@CAHH@Z@4QBHB[eax*4+8]
    mov    eax, DWORD PTR [ecx+edx*4]

; 46   :             }

    ret    4
?get_via_static_imap@triangle_t@@QBEPBVnode_t@@H@Z ENDP    ; triangle_t::get_via_static_imap


?get_via_local_imap@triangle_t@@QBEPBVnode_t@@H@Z PROC NEAR ; triangle_t::get_via_local_imap, COMDAT
; _this$ = ecx

; 49   :             {

    sub    esp, 28                    ; 0000001cH

; 50   :                 const int m[] = { 1, 2, 0, 1, 2, 0, 1 };

    mov    eax, 1
    mov    DWORD PTR _m$[esp+28], eax
    xor    edx, edx
    mov    DWORD PTR _m$[esp+40], eax
    mov    DWORD PTR _m$[esp+52], eax

; 51   :                 return m_nodes[ m[ idx + 2 ] ];

    mov    eax, DWORD PTR _idx$[esp+24]
    mov    DWORD PTR _m$[esp+32], 2
    mov    DWORD PTR _m$[esp+36], edx
    mov    DWORD PTR _m$[esp+44], 2
    mov    DWORD PTR _m$[esp+48], edx
    mov    edx, DWORD PTR _m$[esp+eax*4+36]
    mov    eax, DWORD PTR [ecx+edx*4]

; 52   :             }

    add    esp, 28                    ; 0000001cH
    ret    4
?get_via_local_imap@triangle_t@@QBEPBVnode_t@@H@Z ENDP    ; triangle_t::get_via_local_imap


?get_via_mod@triangle_t@@QBEPBVnode_t@@H@Z PROC NEAR    ; triangle_t::get_via_mod, COMDAT
; _this$ = ecx

; 56   :                 return m_nodes[ ( idx + 2 ) % 3 ];

    mov    eax, DWORD PTR _idx$[esp-4]
    add    eax, 2
    push    esi
    cdq
    mov    esi, 3
    idiv    esi
    pop    esi
    mov    eax, DWORD PTR [ecx+edx*4]

; 57   :             }

    ret    4
?get_via_mod@triangle_t@@QBEPBVnode_t@@H@Z ENDP        ; triangle_t::get_via_mod

?get_via_mod@triangle_t@@QBEPBVnode_t@@H@Z    PROC NEAR
; parameter 1(this): ecx
; parameter 2(idx): 8 + esp
$B48$1:                         ; Preds $B48$0
$LN1255:
        push      edi                                           ;55.13
        mov       edi, ecx                                      ;55.13
$LN1256:
        mov       eax, DWORD PTR [esp+8]                        ;54.24
$LN1257:
        lea       ecx, DWORD PTR [eax+2]                        ;56.41
$LN1258:
        mov       eax, 1431655766                               ;56.47
        imul      ecx                                           ;56.47
        mov       eax, ecx                                      ;56.47
        sar       eax, 31                                       ;56.47
        sub       edx, eax                                      ;56.47
        lea       eax, DWORD PTR [edx+edx]                      ;56.47
        add       eax, edx                                      ;56.47
        sub       ecx, eax                                      ;56.47
$LN1259:
        mov       eax, DWORD PTR [edi+ecx*4]                    ;56.24
        pop       edi                                           ;56.24
        ret       4                                             ;56.24
        ALIGN     4
                                ; LOE
; mark_end;
?get_via_mod@triangle_t@@QBEPBVnode_t@@H@Z ENDP

# Обертка вокруг теста для того, чтобы не вылетать по исключению.
def execute_test_case( message )
    begin
        puts "-- #{message} --"
        yield
    rescue Exception => x
        puts "!!! caught: #{x} !!!"
    end
end

# Исходный класс и его методы.
class Test
    def hello; puts "hello"; end
    def bye; puts "bye"; end
end

# Тестируемый объект. Важно отметить, что все последующие модификации
# класса Test будут отражаться на уже существующем объекте.
t = Test.new

execute_test_case "Original Test class" do t.hello; t.bye end

# Теперь метод bye нам не нужен.
class Test
    remove_method :bye
end

execute_test_case "Test class without bye method" do t.hello; t.bye end

# Теперь заменяем метод hello и возвращаем метод bye
class Test
    def hello; puts "Hello, world"; end
    def bye; puts "Bye, world"; end
end

execute_test_case "Modified Test class" do t.hello; t.bye end

-- Original Test class --
hello
bye
-- Test class without bye method --
hello
!!! caught: undefined method `bye' for #<Test:0x2777040> !!!
-- Modified Test class --
Hello, world
Bye, world

K>>struct Triangle
K>>{
K>>   Node  *nodes[3];
K>>};
K>>

GZ>А зачем указатели? Это оверхед.

K>>class Triangle
K>>{
K>>   public Node A, B, C; // вместо массива переменные
K>>}
K>>

Node node_at( int idx )
{
   switch ( idx )
   {
      case 0: return A;
      case 1: return B;
      // понеслась 
   }
}

VD>

K>>class Triangle
K>>{
K>>   public Node A, B, C; // вместо массива переменные
K>>}
K>>

VD>    public Node this[int index]
VD>    {
VD>        get
VD>        {
VD>            switch (index)
VD>            {
VD>                case 0:  return Node1;
VD>                case 1:  return Node2;
VD>                case 2:  return Node3;
VD>                default: throw new ArgumentOutOfRangeException("index");
VD>            }
VD>        }
VD>    }

VD>

struct Triangle
{
   Node *nodes[3];
   Node* node_at( int idx ) // кольцевой доступ
   {
      static const int imap[] = { 1, 2, 0, 1, 2, 0, 1 };
      return nodes[imap[idx+2]];
   }
};

[skip]

KV>Загрузите, поглядите

1. Уважаемый Кармак пишет настолько хороший код, что можно взять Quake2, изначально требующий 16мб памяти и 90Mhz процессор, скомпилировать и он заработает!
2. Возможно легкое портирование хорошо написанных С/С++ на .NET платформу.
3. Все-таки С++, а не С#/Nemerle... Вон даже на Хаскеле 3D игра есть...

просто новые технологии с рынка не уходят — они его расширяют

// SomeClass.java

public class SomeClass
{
    public void hello()
        {
            // трам-пам-пам...
        }
}

public class SomeClass
{
    public void bye()
        {
            // трам-пам-пам...
        }
}

public class SomeClassTest
{
    static public void main( string args[] )
        {
            SomeClass s = new SomeClass();
            s.hello();
            s.bye();
        }
}

E>Можно ли в Java вводить новые методы в уже существующие классы?

Да. На том построена туча фрэймворков.