rep
movsl

M>>А как часто вы используете массивы?

template < class It >
void variable_arg_num_func( It i_argListBegin, It i_argListEnd )

I often hear people saying that interfaces specify contracts. I believe this is a dangerous myth. Interfaces, by themselves, do not specify much beyond the syntax required to use an object. The interface-as-contract myth causes people to do the wrong thing when trying to separate contracts from implementation, which is a good engineering practice. Interfaces separate syntax from implementation, which is not that useful, and the myth provides a false sense of doing the right engineering.

In reality, the contract is semantics, and these can actually be nicely expressed with some implementation.

interface ICountable<T> : IEnumerable<T> {
  int Count { get; }
}

interface IIndexable<T> : ICountable<T> {
  T this[int i] { get; }
}

struct ArrayBox<T> : IIndexable<T>
{
    private T[] array;

    public ArrayBox(T[] a)
    {
        if (a == null) throw new ArgumentNullException("a");
        array = a;
    }

    public T this[int i] { get { return array[i]; } }
    public int Count { get { return array.Length; } }

    public static implicit operator ArrayBox<T>(T[] array)
    {
        return new ArrayBox<T>(array);
    }

    public IEnumerator<T> GetEnumerator()
    {
        return new Enumerator(array);
    }

    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }

    struct Enumerator : IEnumerator<T>
    {
        T[] array;
        int i;

        internal Enumerator(T[] a)
        {
            array = a;
            i = -1;
        }

        public T Current
        {
            get { return array[i]; }
        }

        public void Dispose()
        {
        }

        object System.Collections.IEnumerator.Current
        {
            get { return array[i]; }
        }

        public bool MoveNext()
        {
            int tmp = i + 1;
            if (tmp < array.Length)
            {
                i = tmp;
                return true;
            }

            return false;
        }

        public void Reset()
        {
            i = -1;
        }
    }
}

G>template < class It >
G>void variable_arg_num_func( It i_argListBegin, It i_argListEnd )
G>

G>И где у нас разница между массивом и списком? Что хошь, то и передавай. То же касается ленивости итераторов и прочего перечисленного. Эт конечно дремучий С++, но разве в новомодных С# нельзя делать так же?

void variable_arg_num_func<T>(IEnumerable<T> args) { ... }
void variable_arg_num_func<T>(params T[] args) { variable_arg_num_func((IEnumerable<T>)args); }