Indexer (Programmierung)

In der objektorientierten Programmierung ermöglicht ein Indexer das Indizieren von Instanzen einer bestimmten Klasse oder Struktur, ähnlich wie bei Arrays. ^{[ 1 ]} Es handelt sich um eine Form der Operatorüberladung .

In C++ kann man die Indizierung emulieren, indem man den []Operator überlädt. Der Ausdruck wird in einen Aufruf der benutzerdefinierten Funktion übersetzt als . ^{[ 2 ]} Hier ist ein Beispiel: a[b...]operator[](a).operator[](b...)

struct vector { int size ; double * data ; vector ( int n ) { size = n ; data = new double [ n ](); } ~ vector (){ size = 0 ; delete [] data ; } double & operator []( int i ) { return data [ i ]; } };#include <iostream>int main ( ) { vector v ( 3 ) ; for ( int i = 0 ; i < v.size ; i ++ ) v [ i ] = i + 1 ; for ( int i = 0 ; i < v.size ; i ++ ) std :: cout << v [ i ] << " \ n " ; return 0 ; }​

Indexer werden über die Getter- und Setter-Methoden implementiert . Sie ähneln Eigenschaften , unterscheiden sich jedoch dadurch, dass sie nicht statisch sind und die Zugriffsmethoden von Indexern Parameter benötigen. Die Getter- und Setter-Methoden werden als Methoden mit der Parameterliste der Indexer-Deklaration aufgerufen, wobei die Setter-Methode weiterhin einen impliziten Parameter besitzt. operator[]value

public class Vector { private double [] _data ;public Vector ( int n ) { _data = new double [ n ]; }public int Size = > _data.Length ;​public double this [ int i ] { get => _data [ i ]; set => _data [ i ] = value ; }public static void Main ( ) { var vector = new Vector ( 3 ) ; for ( var i = 0 ; i < vector.Size ; i ++ ) vector [ i ] = i + 1 ; for ( var i = 0 ; i < vector.Size ; i ++ ) System.Console.WriteLine ( vector [ i ] ) ; } }​​​​

Hier ist ein C#-Beispiel für die Verwendung eines Indexers in einer Klasse: ^{[ 3 ]}

class Family { private List <string> _familyMembers = new List <string> ( ) ;​​public Family ( params string [] members ) { _familyMembers . AddRange ( members ); }public string this [ int index ] { // Der Getter get => _familyMembers [ index ];// Der Set-Accessor mit set => _familyMembers [ index ] = value ; }public int this [ string val ] { // Index anhand des Werts ermitteln (erstes gefundenes Element) get => _familyMembers.FindIndex ( m => m == val ) ; }public int Length = > _familyMembers.Count ; }​

Anwendungsbeispiel:

void Main () { var doeFamily = new Family ( "John" , " Jane" ); for ( int i = 0 ; i < doeFamily.Length ; i ++ ) { var member = doeFamily [ i ]; var index = doeFamily [ member ]; // In diesem Fall identisch mit i, aber es demonstriert die Indexerüberladung , die es ermöglicht, doeFamily anhand des Wertes zu durchsuchen. Console.WriteLine ( $ " { member} ist die Mitgliedsnummer {index} der {nameof(doeFamily)}" ); } }

In diesem Beispiel wird der Indexer verwendet, um den Wert an der n-ten Position zu ermitteln und anschließend die Position in der Liste, auf die dieser Wert verweist. Die Ausgabe des Codes lautet:

John ist Mitglied Nummer 0 der doeFamily Jane ist Mitglied Nummer 1 der doeFamily 

In PHP kann die Indizierung über die vordefinierte ArrayAccessSchnittstelle implementiert werden, ^{[ 4 ].}

class Vector implements ArrayAccess { function __construct ( int $n ) { $this -> size = $n ; $this -> data = array_fill ( 0 , $n , 0 ); }public function offsetGet ( $offset ) : mixed { return $this -> data [ $offset ]; }public function offsetSet ( $offset , $value ) : void { $this -> data [ $offset ] = $value ; }public function offsetExists ( $offset ) : bool {}public function offsetUnset ( $offset ) : void {} }$vector = new Vector ( 3 );for ( $i = 0 ; $i < $vector -> size ; $i ++ ) $vector [ $i ] = $i + 1 ; for ( $i = 0 ; $i < $vector -> size ; $i ++ ) print " { $vector [ $i ] } \n " ;

In Python implementiert man die Indizierung durch Überladen der Methoden ` __getitem__and` und `or` .__setitem__

Importieren Sie das Arrayclass Vector ( object ): def __init__ ( self , n : int ): self . size = n self . data = array . array ( "d" , [ 0.0 ] * n )def __getitem__ ( self , i : int ): return self . data [ i ]def __setitem __ ( self , i : int , value ) : self.data [ i ] = valuevector = Vector ( 3 ) for i in range ( vector . size ): vector [ i ] = i + 1 for i in range ( vector . size ): print ( vector [ i ])

Rust stellt das std::ops::Index- Trait bereit. ^{[ 5 ]}

use std :: ops :: Index ;enum Nucleotide { A , C , G , T , }struct NucleotideCount { a : usize , c : usize , g : usize , t : usize , }impl Index < Nucleotide > for NucleotideCount { type Output = usize ;fn index ( & self , nucleotide : Nucleotide ) - > & Self :: Output { match nucleotide { Nucleotide :: A = > & self.a , Nucleotide :: C = > & self.c , Nucleotide :: G = > & self.g , Nucleotide :: T = > & self.t , } } }​​​let nucleotide_count = NucleotideCount { a : 14 , c : 9 , g : 10 , t : 12 }; assert_eq! ( nucleotide_count [ Nucleotide :: A ], 14 ); assert_eq! ( nucleotide_count [ Nucleotide :: C ], 9 ); assert_eq! ( nucleotide_count [ Nucleotide :: G ], 10 ); assert_eq! ( nucleotide_count [ Nucleotide :: T ], 12 );

In Smalltalk kann man die Indizierung emulieren, indem man beispielsweise die Instanzmethoden `and` get:und `or` definiert. Zum Beispiel in GNU Smalltalk : set:value:

Objekt- Unterklasse: Vektor [ | Daten | ] Vektorklasse erweitern [ neu: n [ | v | v : = super neu . v init : n . ^ v ] ] Vektor erweitern [ init : n [ Daten : = Array neu : n ] ] Vektor erweitern [ Größe [ ^ ( Daten Größe ) ] ] Vektor erweitern [ abrufen: i [ ^ ( Daten an: i ) ] ] Vektor erweitern [ setzen: i Wert: x [ Daten an: i setzen: x ] ] v: = Vektor neu: 3 1 bis: ( v Größe ) tun: [ : i | v setzen: i Wert: ( i + 1 ) ] 1 bis: ( v Größe ) tun: [ : i | ( v abrufen: i ) printNl ] 

• Mutator-Methode