V>>если упомянутая задача неоднократная, то мне все-равно меньше чем тебе париться

VD>Все равно больше те хотел сказать. Представь себе, что задачи схожи только тем, что их все можно представить итератором, а все алгоритмы у них разные и запутанные. Вот пример из реальной жизни. Создавая код для R#-а я заметил, что у меня получается дублирование (захотелось копи-пэстнутся ). Проанализировав ситуацию я понял, что мне нужно создать два разных прохода по одному и тому же алгоритму. Сначала я выделил алгоритм прохода в отдельную функцию, а действие определил делегатом. Но потом почесал репу переписал код с использованием итераторов. Получилось следующее:

template<typename T, typename From, T* Transform(From*)>
class TransformEnumerator : public IEnumerator<T> {
protected:
    IEnumerator<From>* from;
    T* current;
public:
    TransformEnumerator(IEnumerator<From>* from_) : from(from_) {}

    void Reset() { from->Reset(); }
    
    bool MoveNext() { 
        while(from->MoveNext() && (current=Transform(from->Current))==NULL);
        return current!=NULL
    }
    
    T* get_Current() { return current; }
};

class<typename T, typename From, IEnumerator<T>* Nest(From*)>
class NestedEnumerator: public IEnumerator<T> {
protected:
    IEnumerator<From>* from;
    IEnumerator<T>* nest;

public:
    NestedEnumerator(IEnumerator<From>* from_) : from(from_) {}

    void Reset() { 
        from->Reset(); 
        nest=NULL; 
    }

    bool MoveNext() { 
        while(nest == NULL || nest->MoveNext()==false) {
            if(from->MoveNext())
                nest = Nest(from->Current);
            else
                return false;
        }
        return true;
    }

    T* get_Current() { return nest->Current; }

    virtual T* ExtractNest(From* from_) = 0;
};

struct MetaTasks {

    static Assembly* LoadAssembly(String* path) {
        try {
            return Assembly::LoadFrom(path);
        } catch (Exception ex) {
            _result.Errors.Add(new CompilerError(
                "", 0, 0, "",
                "Can't load external meta assembly: "
                + ex.Message));
        }
        return NULL;
    }

    static Type* CheckIMetaRule(Type* type) {
        if(type->GetInterface("IMetaRule"))
            return type;
        return NULL;
    }

    static IEnumerator<Type>* GetAssemblyTypes(Assembly* a) {
        return a->GetTypes()->GetEnumerator();
    }


    static IEnumerator<Type>* GetIMetaRuleTypes(IEnumerator<String> assembliesList) {
    return new TransformEnumerator<Type, Type, MetaTasks::CheckIMetaRule>(
        new NestedEnumerator<Type, Assembly, MetaTasks::GetAssemblyTypes>(
            new TransformEnumerator<Assembly, String, MetaTasks::LoadAssembly>(assembliesList)));
    }
}

foreach(Type *type,  MetaTasks::GetIMetaRuleTypes(assembliesList1)) {
    // тут делай что хошь

    foreach(Type *type,  MetaTasks::GetIMetaRuleTypes(assembliesList2)) {
        // и тут тоже

    }
}

Из обнаруженных мной проблем можно выделить то, что мне не удалось создать итератор, производящий рекурсивный вызов. Это довольно серьезное ограничение, поскольку итераторы как нельзя лучше подошли бы для деревьев и других рекурсивных структур, для которых создавать перечислители особо сложно и неудобно. Будем надеяться, что к release-версии эту проблему устранят.

это выбор скорости в ущерб стройности дизайна языка и простоте его использования

            using(WaitCursor waitCursor = owner.WaitCursor())
            {
            //тут гора тормозного кода который может кинуть исключение итп
            }

    struct iterator
        :iterator_facade_t
            < iterator
            , value_type
            , std::bidirectional_iterator_tag
            >
    {
        friend struct const_iterator;
        iterator()
            :cur(0)
        {}
        iterator(pointer ptr)
            :cur(ptr)
        {}
    private:
        friend struct intrusive_list_t;
        iterator(intrusive_list_node_t* ptr)
            :cur(ptr)
        {}
    private:
        friend struct iterator_core_access;

        void increment() 
        { 
            cur=node_next(cur);
        }
        void decrement() 
        { 
            cur=node_prev(cur);
        }

        reference dereference()const
        { 
            return *static_cast<pointer>(cur);
        }

        bool equal(iterator const& that)const
        {
            return cur==that.cur;
        }
    private:
        intrusive_list_node_t* cur;
    };

Итераторы – это «синтаксический сахар», позволяющий значительно упростить реализацию перечислителей. Суть его заключается в том, что вместо создания класса и нудного превращения циклических алгоритмов просмотра коллекции в последовательный ее просмотр вам достаточно объявить одно свойство или метод, возвращающие интерфейсы IEnumerator, IEnumerable, IEnumerator<T> или IEnumerable<T>. Но это не совсем обычный метод. Дело в том, что он вызывается каждый раз, когда читающий коллекцию код вызывает метод IEnumerator.MoveNext. Если управление покидает этот метод ненасильственным путем, т.е. без принудительного yield return, то процесс перечисления заканчивается, и метод больше вызываться не будет. Если же вернуть управление с помощью оператора yield return, то возвращенное в нем значение станет текущим значением перечисления. Когда перечислителю потребуется следующий элемент (у него вызовут метод MoveNext), управление снова вернется в метод, причем с позиции, следующей непосредственно за той, что привела к выходу из метода в прошлый раз. Так продолжается до тех пор, пока управление не покинет метод без вызова yield return. Это может случиться, если вызвать yield break или просто дать управлению выйти из метода самостоятельно.

void f(T&);

void f(ref<T>);

V>И еще — из компьютерных игр шарпу не вытеснить С++.
Гы. Очень даже вытеснить.(выделено мной — ГВ.) Не сразу конечно. Но через несколько лет народ прийдет к пониманию, что писать игры на Шарпе быстрее и удобнее. Примеры уже есть. Я вроде бы уже говорил. Тут Оранж давал ссылку на 3D RTS. Очень неплохо работает. А по архитектуре на порядок делает разные там именитые WarCraft-ы.

public IEnumerator<НекоторыйТип> GetEnumerator()
{
    for (int i = 0; i < некотораяКоллекци.Count; i++)
            yield return некотораяКоллекци[i];
}

VD>public IEnumerator<НекоторыйТип> GetEnumerator()
VD>{
VD>    for (int i = 0; i < некотораяКоллекци.Count; i++)
VD>            yield return некотораяКоллекци[i];
VD>}
VD>

template<typename my_collection_type>
class CollectionImpl : public collection_base_type {
// ...
IEnumerator<typename collection_base_type::element_type>* GetEnumerator() {
    return new EnumeratorImpl<my_collection_type>(this);
}

template<typename collection_type>
class EnumeratorImpl : public IEnumerator<typename colection_type::element_type> {
public:
      EnumeratorImpl(colection_type* col) : col_(col) { Reset(); }
      void Reset { it_ = col_->begin(); }
      bool MoveNext() { if(it_ != col_->end() && ++it_ != col_->end())  return true; return false; }
      typename colection_type::element_type& Current() { return *it_; }

private:
      typename collection_type::iterator it_;
      collection_type* col_;
}

VD>Видимо фигово, раз постоянно про них забываете.

V>> Ты не обратил внимание, на какую область тебе указал Павел. Там голые, чаще всего односложные математические конструкции, находящиеся внутри охрененейших циклов. Вызов виртуальных методов взамен инлайн может ухудшить быстродействие на порядок.

template<typename T>
struct IValue {
    virtual T getValue() =0;
    virtual void setValue(T value) =0;
};

struct IntValueInline {
    int val;
    IntValueInline(int i=0) : val(i) {}

    int getValue() { return val; }
    void setValue(int value) { val = value; }
};

V>>Что мешает разработать С++ для аппаратного байт-кода?

VD>MSIL разработан под компиляцию в машинный код. Они никогда не интерпретируется и то, что он основан на стэковой машине (видимо именно об этом ты пытаешся вести речь ) ровным счетом ничего не значит. После компиляции получается обычный машинный код ничем от С++-ного не отличающийся.

WH>            using(WaitCursor waitCursor = owner.WaitCursor())
WH>            {
WH>            //тут гора тормозного кода который может кинуть исключение итп
WH>            }
WH>

partial class Form1 : Form
{
    public Form1()
    {
        InitializeComponent();
    }

    void UseWaitCursor()
    {
        if (Form.ActiveForm != null)
        {
            Form currForm = Form.ActiveForm;
            currForm.Cursor = Cursors.WaitCursor;
            Application.Idle += delegate(object sender, System.EventArgs e)
            {
                currForm.Cursor = Cursors.Default;
            };
        }
    }

    private void button1_Click(object sender, EventArgs e)
    {
        // Test!
        UseWaitCursor();
        for (int i = 0; i < int.MaxValue; i++)
        {
        }
    }
}

WH>Ну жертв эффективности я чегото не заметил , а вот совместимость это да... Это они погорячились.

ОК. Изобрази на нем подобный код:
class Test
{
    public IEnumerator<int> GetEven()
    {
        for (int i = 2;; i += 2)
            yield return i;
    }
    
    public IEnumerator<int> GetOdd()
    {
        for (int i = 1;; i += 2)
            yield return i;
    }
}

и если не брать в рассчет библиотечный код (любой, даже входящий в стандарт),

VD>ОК. Изобрази на нем подобный код:
VD>class Test
VD>{
VD>    public IEnumerator<int> GetEven()
VD>    {
VD>        for (int i = 2;; i += 2)
VD>            yield return i;
VD>    }
    
VD>    public IEnumerator<int> GetOdd()
VD>    {
VD>        for (int i = 1;; i += 2)
VD>            yield return i;
VD>    }
VD>}
VD>

template<typename T, T begin, T step, class BaseT = System::Object>
class ValueEnumerator : public BaseT, public IEnumerator<T> {
// тут понятно что, Reset, MoveNext, Current
}

class Test
{
    public:
    IEnumerator<int>* GetEven()
    {
        return new ValueEnumerator<int, 2, 2>;
    }
    
    IEnumerator<int>* GetOdd()
    {
        return new ValueEnumerator<int, 1, 2>;
    }
}

VD>>ОК. Изобрази на нем подобный код:
VD>>class Test
VD>>{
VD>>    public IEnumerator<int> GetEven()
VD>>    {
VD>>        for (int i = 2;; i += 2)
VD>>            yield return i;
VD>>    }
    
VD>>    public IEnumerator<int> GetOdd()
VD>>    {
VD>>        for (int i = 1;; i += 2)
VD>>            yield return i;
VD>>    }
VD>>}
VD>>

V>template<typename T, T begin, T step, class BaseT = System::Object>
V>class ValueEnumerator : public BaseT, public IEnumerator<T> {
V>// тут понятно что, Reset, MoveNext, Current
V>}

V>class Test
V>{
V>    public:
V>    IEnumerator<int>* GetEven()
V>    {
V>        return new ValueEnumerator<int, 2, 2>;
V>    }
    
V>    IEnumerator<int>* GetOdd()
V>    {
V>        return new ValueEnumerator<int, 1, 2>;
V>    }
V>}
V>

V>если упомянутая задача неоднократная, то мне все-равно меньше чем тебе париться

        // Код итератора
        IEnumerable<Type> GetMetaRuleTypes(List<string> metaAssemblys)
        {
            foreach (string path in metaAssemblys)
            {
                Assembly assembly;
                try
                {
                    assembly = Assembly.LoadFrom(path);
                }
                catch (Exception ex)
                {
                    _result.Errors.Add(new CompilerError(
                        "", 0, 0, "",
                        "Can't load external meta assembly: "
                        + ex.Message));
                    continue;
                }

                Type[] types = assembly.GetTypes();

                // Отбираем типы реализующие интрефейс IMetaRule и создаем 
                // их экземлпяры, которые помещаем в массив.
                foreach (Type type in types)
                    if (type.GetInterface("IMetaRule") != null)
                        yield return type;
            }
        }
        
    ...
    // Первое использование
    private void MakeRuleCallCodeForMetaAssembly(
    AstNodeCollection compUnits,
    RMemberMethodImpl callRuleTypeMetaRule,
    RTypeMemberCollection members,
    RSwitchSection switchInCallRule,
    RSwitchSection caseInCallRules,
    RSwitchSectionCollection switchBodyInCallRules,
    List<string> metaAssemblys)
{
    foreach (Type type in GetMetaRuleTypes(metaAssemblys))
    {
        RMemberMethodImpl methodClone = MakeRuleInitCode(

...
    // где-то дальше... второе использование...
                // Загружаем классы из мета-сборок.
            foreach (Type type in GetMetaRuleTypes(metaAsmPaths))
            {
                _metaRules.Add(Utilits.GetFullTypeName(type),
                    (IMetaRule)Activator.CreateInstance(type));
            }

using System;
using System.Collections.Generic;

class Program
{
    // Generic-реализация BinarySearch абстрагированная с помощью интерфейса.
    public static int BinarySearchItf<T>(IList<T> list, int lo, int hi, T value, IComparer<T> comparer)
    {
        while (lo <= hi)
        {
            int i = (lo + hi) >> 1;
            int cmpResult = comparer.Compare(list[i], value);
            if (cmpResult == 0)
                return i;
            else if (cmpResult < 0)
                lo = i + 1;
            else
                hi = i - 1;
        }

        return ~lo;
    }

    public static int BinarySearchItf<T>(IList<T> list, T value, IComparer<T> comparer)
    {
        return BinarySearchItf<T>(list, 0, list.Count - 1, value, comparer);
    }


    // Generic-реализация BinarySearch абстрагированная с помощью делегата.
    public delegate int CompareFunctor<T>(T x, T y);

    public static int BinarySearchDel<T>(IList<T> list, int lo, int hi, T value, CompareFunctor<T> compare)
    {
        while (lo <= hi)
        {
            int i = (lo + hi) >> 1;
            int cmpResult = compare(list[i], value);
            if (cmpResult == 0)
                return i;
            else if (cmpResult < 0)
                lo = i + 1;
            else
                hi = i - 1;
        }

        return ~lo;
    }

    public static int BinarySearchDel<T>(IList<T> list, T value, CompareFunctor<T> compare)
    {
        return BinarySearchDel<T>(list, 0, list.Count - 1, value, compare);
    }

    static void Main(string[] args)
    {
        // Массивы всех типов реализуют IList<T>
        int[] array = new int[] { 2, 4, 7, 8, 10, 20, 22, 23, 24, 26 };

        // Указание спецификации (<int>) нужно чтобы компилятор понял, что int[] нужно привести к IList<int>
        int resItf1 = BinarySearchItf<int>(array, 9, Comparer<int>.Default); // применение реализации компоратора по умолчанию.
        int resItf2 = BinarySearchItf<int>(array, 9, new MyComparer());      // применение "ручной" реализации компоратора.
        int resDel  = BinarySearchDel<int>(array, 9, delegate(int x, int y) { return x - y; }); // применение анонимного метода.

        Console.WriteLine("resItf1 = {0} (~resItf1 = {1})", resItf1, ~resItf1);
        Console.WriteLine("resItf2 = {0} (~resItf2 = {1})", resItf2, ~resItf2);
        Console.WriteLine("resDel  = {0} (~resDel  = {1})", resDel, ~resDel);
    }

    // Реализация дженерик-интерфейса для конкретного типа (int)
    class MyComparer : IComparer<int>
    {
        public int Compare(int x, int y) { return x - y; }
        public bool Equals(int x, int y) { return x == y; }
        public int GetHashCode(int obj)  { return obj; }
    }
}

ЗХ>и еще (вопрос на 5 ): желательно связать эту формулировку со значением слова yield ("выдавать, производить, собирать урожай").

yield
1) (производственный) выход; выход (годных) изделий; выпуск; объем выпуска (продукции)
2) вырабатывать (значение)
3) давать, выдавать (импульс)

foreach(A a in b){...} === (for IEnumerator e = ((IEnumerable)b).GetEnumerator(); e.MoveNext()) {a = e.Current; ... }

ЗХ>и еще (вопрос на 5 ): желательно связать эту формулировку со значением слова yield ("выдавать, производить, собирать урожай").

public class Test
{
  private int[] digits;
  public IEnumerator GetEnumerator()
    {
      return digits.GetEnumerator(); // возвращаем встроенную реализацию IEnumerator для массивов;
    }
    public IEnumerator GetReverseEnumerator()
    {
      for(int i=digits.Count-1; i>=0; i++) // итерируемся сами
          yield return digits[i];  // и отдаем результат по частям
    }
    public IEnumerator AchieveError()
    {
      return digits[0]; // так нельзя - ошибка типа.
    }
}

>> ПК>void f(ref<T>);
>> ПК>

>> ПК>Ну-ка то же самое, да на C# (чур, препроцессоры не предлагать)

>> Щаз скажу страшное -- а зачем в C# проверять на нуль? Это делается автоматом средой с генерацией исключения. Причем с трассировкой стека.

void gun(T *ptr)
 {
  fun(*ptr);
 }

> void gun(T *ptr)
>  {
>   fun(*ptr);
>  }    
>

void f(ref<T>);

>> void gun(T *ptr)
>>  {
>>   fun(*ptr);
>>  }    
>>

ПК>Дык, ты же сделал разыменование — теперь сам виноват Подсказки были бы, если бы передавал указатель. Плюс, если хочется, можно их организовать для случая:

ПК>void f(ref<T>);
ПК>

template <class T>
class ref
 {
    T *ptr; 
     
   public:

    ref(T *ptr_) { ptr=ptr_; ASSERT(ptr_); }    
     
    operator T & () const { return *ptr; }
 };