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

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

Назову конкретные цифры: 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);
        }
    }

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]];
   }
};

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;
   }
}

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

class Triangle
{
public :
    const Node * node_at( int idx ) const 
        { return nodes[ imap( idx + 2 ) ]; }
    Node * node_at( int idx )
        { return nodes[ imap( idx + 2 ) ]; }
private :
    Node * nodes[ 3 ];
    
    static const int imap( int idx )
        {
            static const int m[] = { 1, 2, 0, 1, 2, 0, 1 };
            assert( 0 <= idx && idx < (sizeof(m)/sizeof(m[0])) );
            return m[ idx ];
        }
};