Che cos'è la metà del campo aperto e il valore finale

Question

Cosa significano queste terminologie in C++?

1. fuori end valore

2. metà campo aperto - [begin, off_the_end)

mi sono imbattuto in loro, mentre la lettura su per i loop.

Answer 1

Una gamma socchiusa è uno che comprende la prima elemento, ma esclude l'ultimo.

L'intervallo [1,5) è semiaperta, e consiste dei valori 1, 2, 3 e 4.

"off the end" o "dopo la fine" si riferisce all'elemento appena dopo la la fine di una sequenza, ed è speciale nel fatto che gli iteratori possono indicarlo (ma non si può guardare il valore effettivo, perché non esiste)

Ad esempio, nel seguente codice:

char arr[] = {'a', 'b', 'c', 'd'}; 

char* first = arr 
char* last = arr + 4; 

first ora poi nts al primo elemento dell'array, mentre last punti uno oltre la fine dell'array. Siamo autorizzati a punto uno oltre la fine della matrice (ma non due passato), ma non c'è permesso per tentare di accedere all'elemento in quella posizione:

// legal, because first points to a member of the array 
char firstChar = *first; 
// illegal because last points *past* the end of the array 
char lastChar = *last; 

nostri due puntatori, first e last definiscono insieme un intervallo, di tutti gli elementi tra di loro.

Se è un intervallo aperto mezzo, allora contiene l'elemento puntato dal first, e tutti gli elementi intermedi, ma non l'elemento puntato da last (che è buono, non perché fa effettivamente indicare un elemento valido)

In C++, tutti gli algoritmi di libreria standard operano su tali intervalli aperti a metà.Ad esempio, se voglio copiare l'intero array a qualche altra posizione dest, faccio questo:

std::copy(first, last, dest) 

Un semplice ciclo for segue in genere un modello simile:

for (int i = 0; i < 4; ++i) { 
    // do something with arr[i] 
} 

Questo ciclo va dal 0 e 4, ma esclude il valore finale, quindi l'intervallo di indici rivestiti è semiaperta, specificamente [0, 4)

Answer 2

Questi non sono termini specifici di C++, sono termini matematici generali.

[] e() indicano se l'intervallo è comprensivo/esclusiva del punto finale:

• [include il punto finale
• (esclude l'endpoint
• [] = 'chiuso', comprende sia endpoint
• () = 'aperto', esclude entrambi gli endpoint
• [) e (] sono entrambi 'semiaperta', e includere solo un endpoint

maggior C++ per-loop coprono una gamma semiaperta (si includono il primo elemento: ad esempio for int i=0;, ma esclude l'elemento finale: i < foo, non i ≤ foo)

Answer 3

Come spiegato in altre risposte, mezza ope n intervallo è anche un termine matematico e l'uso di questo termine nel contesto di programmazione , è implicito che il punto di partenza è incluso e il punto finale è escluso.

Che cosa significa in realtà nel contesto della programmazione in C/C++? Diciamo che stamperai gli elementi di un array intero. Parlando per il linguaggio C, poiché non hai conoscenze run-time per la dimensione dell'array, hai due possibilità. O devi fornire la dimensione della matrice e, quindi, la firma della funzione sarà come di seguito;

void printArray(int * array, int size); 

o si deve utilizzare il gamma socchiusa, il che significa, è necessario fornire sia iniziare e puntatore fine (e la funzione sta per elaborare compreso l'inizio, escludendo alla fine) supplementare al matrice stessa. E la firma della funzione sarà la seguente;

void printArray(int * array, int * begin, int * end); 

Per illustrare, ecco un esempio per fornire la dimensione della matrice;

#include <stdio.h> 

void printArray(int * array, int size) 
{ 
    printf("Array: "); 

    for(int i = 0; i < size; i++) 
     printf("%2d ", array[i]); 

    printf("\n"); 
} 

int main() 
{ 
    int array[5] = { 1, 2, 3, 4, 5 }; 

    printArray(array, 5); 

    return 0; 
} 

Nell'esempio precedente, si sono passati due parametri alla funzione printArray come è ovvio sulla firma funzione, il puntatore al primo elemento della matrice (o la matrice stessa), e la dimensione di l'array.

Tuttavia, come ho scritto sopra, possiamo anche usare la gamma di apertura parziale nella firma della funzione che può essere vista come di seguito;

#include <stdio.h> 

void printArray(int * array, int * begin, int * end) 
{ 
    printf("Array: "); 

    for(int * index = begin; index != end; index++) 
     printf("%2d ", *index); 

    printf("\n"); 
} 

int main() 
{ 
    int array[5] = { 1, 2, 3, 4, 5 }; 

    printArray(array, array, array+5); 

    return 0; 
} 

Entrambi il codice produrrà la stessa uscita come può essere visto di seguito;

Array: 1 2 3 4 5 

Come si può vedere, la funzione printArray stamperà la funzione per la gamma [begin, end). Lo index, che in realtà è un puntatore agli elementi dell'array intero, inizia da begin e include lo begin e il ciclo chiuso termina quando index corrisponde al puntatore end, escluso per elaborare lo end. Questo ho chiamato intervallo semiaperto.

Intervallo semiaperto è la convenzione C++.