Matrici e puntatori in C ++ - dummies

Il nome dell'array è un puntatore all'array stesso. L'array è una sequenza di variabili memorizzate. Il nome dell'array punta al primo elemento.

Questa è una domanda interessante sui puntatori: puoi avere un'intestazione di funzione, come la seguente riga, e usare semplicemente sizeof per determinare quanti elementi ci sono nell'array? In tal caso, questa funzione non dovrebbe richiedere al chiamante di specificare la dimensione dell'array.

int AddUp (int Numbers []) {

Considera questa funzione trovata nell'esempio Array01 e in main () che la chiama:

void ProcessArray (int Numbers []) { cout << "funzione interna: la dimensione in byte è" << sizeof (Numeri) << endl;} int main (int argc, char * argv []) {int MyNumbers [] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; cout << "funzione esterna: la dimensione in byte è"; cout << sizeof (MyNumbers) << endl; ProcessArray (MyNumbers); return 0;}

Quando si esegue questa applicazione, ecco ciò che si vede:

Funzione esterna: la dimensione in byte è 40 Funzione Inside: la dimensione in byte è 4

Al di fuori della funzione, il codice sa che la dimensione dell'array è di 40 byte. Ma perché il codice pensa che la dimensione è 4 dopo che è all'interno della matrice? Il motivo è che anche se sembra che tu stia passando un array, stai davvero passando un puntatore a un array. La dimensione del puntatore è solo 4, ed è così che viene stampata la linea finale.

La dichiarazione degli array ha una leggera idiosincrasia. Quando dichiari un array dando un numero definito di elementi, come

int MyNumbers [5];

il compilatore sa che hai un array e l'operatore sizeof ti dà la dimensione dell'intero array. Il nome dell'array, quindi, è entrambi un puntatore e un array! Ma se dichiari un'intestazione di funzione senza una dimensione dell'array, come

void ProcessArray (int Numbers []) {

il compilatore considera questo come un puntatore e nulla più. Quest'ultima riga è, in effetti, equivalente alla seguente riga:

void ProcessArray (int * Numbers) {

Così, all'interno delle funzioni dichiarate da una riga, le seguenti due righe di codice sono equivalenti <: Numeri [3] = 10; * (Numeri + 3) = 10;

Questa equivalenza significa che se si utilizza una dichiarazione extern su un array, come

extern int MyNumbers [];

e quindi prendere la dimensione di questo array, il compilatore verrà confuso. Ecco un esempio: se hai due file, numeri. cpp e principale. cpp, dove numeri. cpp dichiara un array e main. cpp lo dichiara esternamente (come mostrato nell'esempio di Array02), si otterrà un errore del compilatore se si chiama sizeof:

# include using namespace std; extern int MyNumbers []; int main (int argc, char * argv []) {cout << sizeof (MyNumbers) << endl; return 0;}

In Code:: Blocks, il compilatore gcc ci dà questo errore:

error: applicazione non valida di 'sizeof' a tipo incompleto 'int []'

La soluzione è mettere la dimensione della matrice tra parentesi.Assicurati che la dimensione sia la stessa dell'altro file del codice sorgente! Puoi modificare il compilatore modificando il numero e

non visualizzerà un errore . Ma questo è uno stile di programmazione scadente e solo la richiesta di errori. Sebbene un

array sia semplicemente una sequenza di variabili tutte adiacenti l'una all'altra in memoria, il nome di un array è in realtà solo un puntatore al primo elemento dell'array. Puoi usare il nome come puntatore. Tuttavia, fallo solo quando hai veramente bisogno di lavorare con un puntatore. Dopo tutto, non hai davvero alcun motivo per scrivere codice criptico, come * (Numbers + 3) = 10;. Il contrario è anche vero. Guardate questa funzione:

void ProcessArray (int * Numbers) {cout << numbers [1] << endl;}

Questa funzione accetta un puntatore come parametro, ma vi accede come una matrice. Di nuovo, non scrivere codice come questo; invece, dovresti capire

perché il codice come questo funziona . In questo modo, acquisirai una conoscenza più approfondita degli array e di come vivono all'interno del computer, e questa conoscenza, a sua volta, può aiutarti a scrivere codice che funzioni correttamente. Anche se il nome dell'array è solo un puntatore, il nome di un array di numeri interi non è esattamente la stessa cosa di un puntatore a un intero. Dai un'occhiata a queste righe di codice (trovate nell'esempio di Array03):

int LotsONumbers [50]; int x; LotsONumbers = & x;

Puntare il puntatore

di LotsONumbers su qualcosa di diverso: qualcosa dichiarato come numero intero. Il compilatore non ti permette di farlo; ottieni un errore Questo non sarebbe il caso se LotsONumbers fosse dichiarato come int * LotsONumbers; allora questo codice funzionerebbe. Ma come scritto, questo codice ti dà un errore del compilatore. E che ci crediate o no, ecco l'errore del compilatore nel Codice:: Blocchi: errore: tipi incompatibili nell'assegnazione di 'int *' a 'int [50]'

Questo errore implica che il compilatore veda un distinzione definitiva tra i due tipi, int * e int []. Tuttavia, il nome dell'array è effettivamente un puntatore e puoi usarlo come uno; non puoi semplicemente fare tutto ciò che puoi con un normale puntatore, ad esempio riassegnarlo.

Quando si utilizzano gli array, prendere nota dei seguenti suggerimenti. Questi ti aiuteranno a mantenere i tuoi array privi di bug:

Mantieni il tuo codice coerente. Se dichiari, ad esempio, un puntatore a un numero intero, non trattarlo come una matrice.

• Mantieni il tuo codice chiaro e comprensibile. Se passi dei puntatori, va bene prendere l'indirizzo del primo elemento, come in & (MyNumbers [0]) se questo rende il codice più chiaro - sebbene sia equivalente a MyNumbers.

• Quando dichiari un array, cerca sempre di mettere un numero tra parentesi, a meno che non stai scrivendo una funzione che accetta un array.

• Quando si utilizza la parola chiave extern per dichiarare un array, andare avanti e inserire le dimensioni dell'array tra parentesi. Ma sii coerente! Non usare un numero una volta e un numero diverso un'altra volta. Il modo più semplice per essere coerenti è usare una costante, come const int ArraySize = 10; in un file di intestazione comune e quindi utilizzarlo nella dichiarazione dell'array: int MyArray [ArraySize];.