別の配列の一部だけを指す配列を作成しますか？

Question

私は参照型要素を含む巨大な配列を持っています、そして、私は本質的にその1つの大きな配列の特定の部分を指し示す多くの他の配列を作成したいと思います。

つまり、「インデクサ」または「長さのポインタ」を作成したいと考えています。

C++では、ポインタを使用するのは簡単ですし、ポインタごとに長さを割り当てることができます。たとえば、長さのポインタを含む構造体を作成します。

C＃/ .NETでこれをどのように達成できますか？

何かをコピーしないようにすることがポイントです。メモリ内に既に存在する配列の特定の部分へのポインタが必要なだけです。

アイデア？

Answer 1

ジョンの提案はArraySegment<T>を使用している可能性が高いです。しかし、配列の内部へのポインタを表現したいのであれば、C++のやり方では、そのためのコードがあります。いかなる保証も表明されていません。お客様の責任において使用してください。

このコードでは、内部ポインタの長さは決して追跡されませんが、必要に応じてその機能を追加するのは簡単です。それはあなたがArraySegment<T>ような何かを探しているように聞こえる

double[] arr = new double[10]; 
var p0 = (ArrayPtr<double>)arr; 
var p5 = p0 + 5; 
p5[0] = 123.4; // sets arr[5] to 123.4 
var p7 = p0 + 7; 
int diff = p7 - p5; // 2 

Answer 2

：よう

internal struct ArrayPtr<T> 
{ 
    public static ArrayPtr<T> Null { get { return default(ArrayPtr<T>); } } 
    private readonly T[] source; 
    private readonly int index; 

    private ArrayPtr(ArrayPtr<T> old, int delta) 
    { 
    this.source = old.source; 
    this.index = old.index + delta; 
    Debug.Assert(index >= 0); 
    Debug.Assert(index == 0 || this.source != null && index < this.source.Length); 
    } 

    public ArrayPtr(T[] source) 
    { 
    this.source = source; 
    index = 0; 
    } 

    public bool IsNull() 
    { 
    return this.source == null; 
    } 

    public static bool operator <(ArrayPtr<T> a, ArrayPtr<T> b) 
    { 
    Debug.Assert(Object.ReferenceEquals(a.source, b.source)); 
    return a.index < b.index; 
    } 

    public static bool operator >(ArrayPtr<T> a, ArrayPtr<T> b) 
    { 
    Debug.Assert(Object.ReferenceEquals(a.source, b.source)); 
    return a.index > b.index; 
    } 

    public static bool operator <=(ArrayPtr<T> a, ArrayPtr<T> b) 
    { 
    Debug.Assert(Object.ReferenceEquals(a.source, b.source)); 
    return a.index <= b.index; 
    } 

    public static bool operator >=(ArrayPtr<T> a, ArrayPtr<T> b) 
    { 
    Debug.Assert(Object.ReferenceEquals(a.source, b.source)); 
    return a.index >= b.index; 
    } 

    public static int operator -(ArrayPtr<T> a, ArrayPtr<T> b) 
    { 
    Debug.Assert(Object.ReferenceEquals(a.source, b.source)); 
    return a.index - b.index; 
    } 

    public static ArrayPtr<T> operator +(ArrayPtr<T> a, int count) 
    { 
    return new ArrayPtr<T>(a, +count); 
    } 

    public static ArrayPtr<T> operator -(ArrayPtr<T> a, int count) 
    { 
    return new ArrayPtr<T>(a, -count); 
    } 

    public static ArrayPtr<T> operator ++(ArrayPtr<T> a) 
    { 
    return a + 1; 
    } 

    public static ArrayPtr<T> operator --(ArrayPtr<T> a) 
    { 
    return a - 1; 
    } 

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

    public static bool operator ==(ArrayPtr<T> x, ArrayPtr<T> y) 
    { 
    return x.source == y.source && x.index == y.index; 
    } 

    public static bool operator !=(ArrayPtr<T> x, ArrayPtr<T> y) 
    { 
    return !(x == y); 
    } 

    public override bool Equals(object x) 
    { 
    if (x == null) return this.source == null; 
    var ptr = x as ArrayPtr<T>?; 
    if (!ptr.HasValue) return false; 
    return this == ptr.Value; 
    } 

    public override int GetHashCode() 
    { 
    unchecked 
    { 
     int hash = this.source == null ? 0 : this.source.GetHashCode(); 
     return hash + this.index; 
    } 
    } 

    public T this[int index] 
    { 
    get { return source[index + this.index]; } 
    set { source[index + this.index] = value; } 
    } 
} 

今、私たちはものを行うことができます。私の以前の思想とは逆に、はにインデクサーがあり、IEnumerable<T>などを実装しています。これは明示的なインターフェイスで行われています。

サンプルコード：

using System; 
using System.Collections.Generic; 

static class Test 
{ 
    static void Main() 
    { 
     string[] original = { "The", "quick", "brown", "fox", "jumped", "over", 
       "the", "lazy", "dog" }; 

     IList<string> segment = new ArraySegment<string>(original, 3, 4); 
     Console.WriteLine(segment[2]); // over 
     foreach (var word in segment) 
     { 
      Console.WriteLine(word); // fox jumped over the 
     } 
    } 
} 

EDIT：コメントで述べたように、ArraySegment<T>は、.NET 4.5でだけは本当に "完全に機能" です。 .NET 4 versionは、の任意のインターフェイスを実装していません。

Answer 3

あなたは、LINQを使用することができます。

yourArray.Skip(startIndex).Take(numberToTake) 

クエリが遅延評価されます。