Tạo một mảng chỉ tới một phần của mảng khác?

Question

Tôi có một mảng lớn chứa các phần tử kiểu tham chiếu và tôi muốn tạo nhiều mảng khác về cơ bản chỉ trỏ đến các phần cụ thể của một mảng lớn đó.

Nói cách khác, tôi muốn tạo "chỉ mục" hoặc "con trỏ có độ dài".

Trong C++ thật dễ dàng để làm như vậy bằng cách sử dụng con trỏ và cho mỗi con trỏ gán một chiều dài, ví dụ tạo một cấu trúc có chứa một con trỏ có độ dài.

Làm thế nào tôi có thể đạt được điều này trong C# /. NET?

Toàn bộ vấn đề là tránh sao chép bất kỳ thứ gì, tôi chỉ muốn con trỏ đến các phần cụ thể trong một mảng đã tồn tại trong bộ nhớ.

Bất kỳ ý tưởng nào?

Answer 1

Đề xuất của Jon về việc sử dụng ArraySegment<T> có thể là những gì bạn muốn. Tuy nhiên, nếu bạn muốn đại diện cho một con trỏ đến bên trong của một mảng, cách bạn có thể trong C++, đây là một số mã cho điều đó. Không có bảo hành được thể hiện hoặc ngụ ý, sử dụng có nguy cơ của riêng bạn.

Mã này không theo dõi "độ dài" của con trỏ bên trong theo bất kỳ cách nào, nhưng thật dễ dàng để thêm tính năng đó nếu bạn muốn.

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

Bây giờ chúng ta có thể làm những thứ như:

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

Có vẻ như bạn đang tìm kiếm cái gì đó như ArraySegment<T>. Trái ngược với những suy nghĩ trước đây của tôi, nó không có trình chỉ mục và triển khai IEnumerable<T> v.v. - nó chỉ được thực hiện với giao diện rõ ràng.

Mẫu mã:

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: Như đã nêu trong các ý kiến, ArraySegment<T> là chỉ thực sự "đầy đủ chức năng" trong .NET 4.5. .NET 4 version không triển khai bất kỳ giao diện nào.

Answer 3

Bạn có thể sử dụng LINQ:

yourArray.Skip(startIndex).Take(numberToTake) 

Truy vấn được lười biếng đánh giá.