Come trasferire argomenti nel C. Diversi dettagli sulla funzione principale. Il valore pratico del trasferimento dei dati al programma

Argomenti opzionali e denominati

Argomenti opzionali

Nella versione C # 4.0, un nuovo strumento che migliora la convenienza di specificare gli argomenti durante la chiamata di un metodo. Questo strumento è chiamato argomenti opzionali E consente di determinare il valore predefinito per il parametro del metodo. Questo valore Sarà utilizzato per impostazione predefinita se l'argomento corrispondente non è specificato per il parametro quando viene chiamato il metodo. Di conseguenza, specificare l'argomento per tale parametro non è necessario. Gli argomenti opzionali consentono di semplificare la chiamata ai metodi in cui gli argomenti predefiniti vengono applicati ad alcuni parametri. Possono anche essere usati come una forma "abbreviata" di metodi di sovraccarico.

Lo stimolo principale per aggiungere argomenti opzionali è stata la necessità di semplificare l'interazione con le strutture Com. In diversi modelli di oggetti Microsoft (ad esempio, Microsoft Office), la funzionalità è fornita tramite le strutture Com, molte delle quali sono state scritte molto tempo fa e sono progettate per utilizzare parametri opzionali.

Di seguito è riportato un esempio di utilizzo degli argomenti opzionali:

Usando il sistema; usando sistema.Collections.genic; Usando il sistema.linq; Usando il sistema.Text; Espace ConsoleApplication1 (programma di classe (// Argomenti B e con specificare quando si chiama opzionalmente statico int MySUM (INT A, INT B \u003d 5, INT C \u003d 10) (restituire A + B + C;) Statico Void MAIN () (INT Sum1 \u003d mysum (3); int sum2 \u003d mysum (3,12); console.writeline ("sum1 \u003d" + sum1); console.writelline ("sum2 \u003d" + sum2); console.readline ();)))

Va tenuto presente che tutti gli argomenti opzionali devono certamente essere indicati a destra di obbligatorio. Oltre ai metodi, gli argomenti opzionali possono essere utilizzati in designer, indicizzatori e delegati.

Il vantaggio degli argomenti opzionali è, in particolare, nel fatto che semplificano il trattamento di programmazione con sfide complesse di metodi e costruttori. Infatti, spesso nel metodo devi impostare più parametri del solito. E in tali casi, alcuni di questi parametri possono essere effettuati facoltativi a causa dell'uso accurato degli argomenti opzionali. Ciò significa che sono necessari solo tali argomenti che sono importanti in questo caso particolare, e non tutti gli argomenti che altrimenti devono essere obbligatori. Questo approccio ci consente di razionalizzare il metodo e semplificare l'appello di programmazione ad esso.

Nominato argomenti.

Un altro funzionalitàche è stato aggiunto a c # con la versione di uscita della versione .NET 4.0, è il supporto del cosiddetto argomenti nominati (argomenti nominati). Come è noto, quando si trasferiscono argomenti, la procedura per il loro seguente, di norma, dovrebbe coincidere con tale ordine in cui i parametri sono definiti nel metodo stesso. In altre parole, il valore dell'argomento è assegnato al parametro con la sua posizione nell'elenco degli argomenti.

Questa restrizione è progettata per superare gli argomenti denominati. L'argomento denominato consente di specificare il nome del parametro a cui viene assegnato il suo valore. E in questo caso, l'ordine degli argomenti non importa più. Pertanto, nominati argomenti in una certa misura simile a quelli menzionati iniziali iniziali di oggetti, sebbene differiscano da loro con la loro sintassi. Per specificare l'argomento del nome, viene utilizzato il modulo successivo di sintassi:

nome del parametro: valore

Qui nome del parametro Indica il nome del parametro a cui viene passato il valore. Naturalmente, il parametro_name deve significare il nome del parametro valido per il metodo chiamato.

Tag: Parametri riga di comando

Impostazioni della riga di comando

C e - linguaggio compilato. Dopo il montaggio, il programma è un file eseguibile (non consideriamo la creazione di biblioteche dinamiche, driver, ecc.). I nostri programmi sono molto semplici e non contengono librerie di runtime (librerie di runtime), quindi possono essere trasferite a un computer con lo stesso sistema operativo (e architettura simile) e sono in esecuzione lì.

Il programma durante l'avvio può assumere parametri. Sono gli argomenti della funzione principale. Vista generale della funzione principale Avanti

VOID MAIN (INT ARGC, CHAR ** ARGV) (...)

Il primo argomento ARGC è il numero di funzioni di parametro trasmesso. Il secondo argomento è una serie di stringhe - i parametri stesso sono in realtà. Poiché i parametri della funzione possono essere qualsiasi, quindi vengono trasmessi come stringhe e il programma stesso deve smontarli e portare al tipo desiderato.

Il primo argomento (ARGV) è sempre il nome del programma. In questo caso, il nome viene visualizzato a seconda di dove è stato in esecuzione il programma.

#Includere. #Includere. Void Main (INT ARGC, Char ** Argv) (Printf ("% s", argv);)

Ora impara a lavorare un po 'con la riga di comando. Sarà necessario per trasmettere gli argomenti al nostro programma. La combinazione dei tasti Win + R chiama la finestra "Esegui". Digita cmd in esso e aprirai la riga di comando. Puoi anche trovare la ricerca cmd.exe nel menu Start. In Unix-Like sistemi operativioh, puoi chiamare il programma "Terminale".

Non studieremo molte squadre. Solo quelli che saranno necessari nel lavoro.

Standard per tutti i sistemi operativi, la transizione del comando CD alla cartella desiderata. Ci sono due nomi riservati -. (Punto) e .. (due punti). Il punto è il nome della cartella corrente.

Non va da nessuna parte

Appello alla cartella principale

Transizione alla cartella principale

Per la transizione all'indirizzo del CD desiderato è scritto. Ad esempio, è necessario andare su Windows alla cartella C: \\ Windows \\ System32

CD C: \\ Windows \\ System32

In Linux se è necessario andare alla cartella / var / mysql

CD / VAR / MySQL

Se il percorso contiene spazi, è scritto in virgolette

CD "D: \\ Docughi e impostazioni \\ prolog"

Il terminale ha le seguenti funzioni utili: se si preme la freccia su, verrà visualizzato il comando esecuzione precedente. Se si preme la scheda, il terminale proverà ad aggiungere una stringa al comando noto ad esso, o aggiungere il percorso, disattivando tutte le cartelle e i file nella cartella corrente.
Componi CD C: \\
Premere Tab e vedere cosa sta succedendo.

Un altro comando dir importante su Windows e LS su Linux, visualizza il contenuto della cartella corrente nella console (la cartella in cui sei attualmente)

Il tuo programma ha restituito il tuo nome completo. Vai alla cartella in cui si trova il tuo programma e vedi i suoi contenuti.

Ora, dopo che siamo passati alla nostra cartella, puoi eseguire il nostro programma. Per fare questo, digita il suo nome.

Nota: il nome è cambiato. Poiché il programma è chiamato dalla sua cartella, viene visualizzato rispetto al nome. Ora cambierai il programma e fallo tira fuori tutti gli argomenti. chi è trasferito a lei.

#Includere. #Includere. Void principale (int Argc, char ** argv) (int I; per (i \u003d 0; io< argc; i++) { printf("%s\n", argv[i]); } }

Raccogli il progetto. Prima del montaggio, assicurarsi che il programma sia chiuso. Ora chiama il programma passandolo diversi argomenti. Per fare ciò, scrivi il nome del programma e attraverso lo spazio argomento

Ora scriviamo un programma che riceve due argomenti del numero e visualizza la loro somma

#Includere. #Includere. #Includere. Void Main (INT ARGC, Char ** Argv) (INT A, B; IF (ARGC! \u003d 3) (ERRORF ("Errore (" Errore: Trovato% D Distruzione. Ha bisogno esattamente 2 ", ARGC-1); uscita (1); ) A \u003d ATOI (ARGV); B \u003d ATOI (ARGV); PrintF ("% D", A + B);)

Raccogliamo e chiamiamo

Quindi, la maggior parte dei programmi funziona. Clicca su un'etichetta, chiami il programma a cui si riferisce. La maggior parte dei programmi prende anche vari argomenti. Ad esempio, puoi chiamare browser Firefox. Dalla riga di comando e agli argomenti di trasferimento
Firefox.exe "www.mozilla.org" Site "e aprirà immediatamente i siti in due schede agli indirizzi specificati.

Molti comandi standard hanno anche parametri. È accettato in Windows che iniziano con un aspetto diretto, in UNIX con un meno o due meno. per esempio

Visualizza solo le cartelle e nel terminale Linux

LS -L visualizza tutti i file e le cartelle con gli attributi

Per la visualizzazione aggiuntiva comandi di Windows. Componi la linea di comando della Guida o vedere la guida (è facile da trovare su Internet). Per i team di Linux e le loro opzioni, molto di più, e alcuni di loro sono lingue di programmazione indipendenti, quindi vale la pena imparare almeno un set minimo e le loro opzioni.

Durante la creazione di un'applicazione console nel linguaggio di programmazione C ++, una stringa viene creata automaticamente molto simile a questo:

Int principale (int Argc, char * argv) // principale () parametri funzione

Questa stringa è un'intestazione funzione principale Principale (), i parametri di ARGS e ARGV sono annunciati tra parentesi. Quindi, se si esegue il programma attraverso la riga di comando, è possibile trasferire qualsiasi informazione su questo programma, per questo, ed esiste parametri ARGC e ARGV. Il parametro ARGC ha un tipo di dati int e contiene il numero di parametri trasmessi alla funzione principale. Inoltre, ARGC è sempre almeno 1, anche quando non trasmettiamo alcuna informazione, dal momento che il primo parametro è il nome della funzione. Il parametro ARGV è una serie di puntatori a stringhe. Attraverso la riga di comando, è possibile trasmettere solo un tipo di stringa. Puntatori e linee sono due grandi argomenti che vengono creati sezioni separate. Quindi è attraverso il parametro ARGV e qualsiasi informazione viene trasmessa. Svilupperemo un programma che porteremo attraverso il comando windows String.e trasmettere alcune informazioni ad esso.

// argc_argv.cpp: Determina il punto di ingresso per l'applicazione della console. #Include "stdafx.h" #include Usando il namespace std; Int Main (INT ARGC, CHAR * ARGV) (se (ARGC\u003e<< argv<

// codice codice :: blocchi

// Dev-C ++ Code

// argc_argv.cpp: Determina il punto di ingresso per l'applicazione della console. #Includere. Usando il namespace std; Int Main (int Argc, char * argv) (se (ARGC\u003e 1) // Se trasmettiamo argomenti, l'ArgC sarà maggiore di 1 (a seconda del numero di argomenti) (cout<< argv<

Dopo aver timido il programma, aprire la riga di comando di Windows e trascina nella finestra della riga di comando del nostro programma nella finestra della riga di comando, il percorso completo del programma verrà visualizzato sulla riga di comando (ma è possibile prescrivere il percorso Il programma manuale), quindi puoi fare clic ACCEDERE E il programma inizierà (vedi figura 1).

Figura 1 - Impostazioni della funzione principale

Dal momento che abbiamo appena lanciato il programma e non ha superato alcun argomento, il messaggio non è apparso argomenti. La figura 2 mostra l'inizio dello stesso programma attraverso la riga di comando, ma già con la trasmissione dell'argomento aperto.

Figura 2 - Parametri della funzione principale

L'argomento è la parola aperta, come può essere visto dall'immagine, questa parola è apparsa sullo schermo. È possibile trasmettere immediatamente diversi parametri, separarli l'uno con l'altro. Se è necessario passare il parametro costituito da diverse parole, devono essere prese in doppie citazioni, e quindi queste parole saranno considerate come un parametro. Ad esempio, la figura mostra il lancio del programma, con il trasferimento dell'argomento costituito da due parole - funziona.

Figura 3 - Parametri della funzione principale

E se rimuovi le virgolette. Vedrò solo la parola. Se non si prevede di trasmettere alcuna informazione quando si avvia il programma, è possibile eliminare argomenti nella funzione principale (), è anche possibile modificare i nomi degli argomenti. A volte c'è una modifica dei parametri ARGC e ARGV, ma tutto dipende dal tipo di applicazione creata o dall'ambiente di sviluppo.

Con la creazione automatica di un'applicazione console nel linguaggio di programmazione C ++, la funzione principale viene creata automaticamente molto simile a questo:

int Main (int Argc, char * argv)
{…}

L'intestazione della funzione contiene la firma della funzione principale principale () con argomenti ARGS e ARGV.
Se si esegue il programma attraverso la riga di comando, è possibile trasferire qualsiasi informazione su questo programma. Per questo, ci sono argomenti della riga di comando ARGC e ARGV.
Il parametro ARGC ha un tipo int e contiene il numero di parametri trasmessi alla funzione principale. Inoltre, ARGC è sempre almeno 1, anche quando le funzioni principali non vengono trasmesse da alcuna informazione, poiché il nome dell'applicazione è considerato il primo parametro.
Il parametro ARGV è una serie di puntatori a stringhe. Attraverso la riga di comando, è possibile trasmettere solo un tipo di stringa.

Quando si avvia il programma attraverso la riga di comando di Windows, è possibile trasmettere alcune informazioni ad esso. In questo caso, la riga di comando guarderà:
Disc: \\ Path \\ Name.exe Argument1 Argument2 ...

Gli argomenti della riga di comando sono separati da uno o più spazi.

L'argomento ARGV contiene il nome completo dell'applicazione:

#Includere.
usando il namespace std;

cout.<< argv << endl;

Ritorno 0;
}

Risultato dell'esecuzione

Esempio: calcolando il lavoro di due numeri interi
Il programma utilizza una funzione di conversione delle stringhe su un intero strtment () da qui.

#Includere.
usando il namespace std;
int strlloint (Char * s) (...)
int principale (int Argc, char * argv) (

Int a \u003d 0, b \u003d 0;

Se (Argc\u003e 1)

a \u003d strtareint (argv);

Se (Argc\u003e 2)

b \u003d Strtoint (ARGV);

cout.<< a <<«*» << b << «= « << a*b << endl;

Ritorno 0;
}

Avvio del programma viene effettuato come

Risultato dell'esecuzione

Debug del programma con argomenti della riga di comando

Per trasferire gli argomenti della riga di comando durante il debug del programma, è necessario contattare il menu Proprietà Progetto.


Sulla scheda Proprietà di configurazione -\u003e Debug scegliere Team di argomenti E chiedi ai loro valori.

Quando si avvia il programma in modalità Debug, gli argomenti immessi saranno percepiti dal programma come argomenti della riga di comando.

Una volta interessato, il contenuto del processo principale del processo principale in Linux. Ha condotto alcuni sondaggi e ora ti presenterò il risultato.

Funzione principale Descrizione Opzioni:
1. int principale ()
2. Int Main (INT ARGC, CHAR ** ARGV)
3. Int Main (INT ARGC, Char ** Argv, Char ** env)
4. INT PRINCIPARE (INT ARGC, CHAR ** ARGV, CHAR ** ENV, ELFW (AUXV_T) AUXV)
5. Int Main (INT ARGC, Char ** Argv, Char ** env, Char ** Apple)

Argc - numero di parametri
Argv - Array zero-terminale dei puntatori a riga di comando Stringhe parametri
ENV - Array a zero-terminale dei puntatori a file di variabili di ambiente. Ogni riga in formato nome \u003d valore
AUXV - Array del valore ausiliario (disponibile solo per PowerPC)
Apple - percorso al file eseguibile (in Macos e Darwin)
Vettore ausiliario - un array con varie informazioni aggiuntive, come un ID utente efficiente, un segno di un po 'di bit, la dimensione della pagina di memoria, ecc.

La dimensione del segmento Stack può essere considerata nel file Maps:
Gatto / proc / 10918 / mappe
…
7ffffffa3000-7FFFFFFFFFF000 RW-P 00000000 00:00 0
…

Prima che il bootloader sia controllato in principale, inizializza il contenuto degli array dei parametri della riga di comando, variabili di ambiente, vettore ausiliario.
Dopo l'inizializzazione, la parte superiore dello stack sembra questa per la versione a 64 bit.
Indirizzo senior da sopra.

1.	0x7FFFFFFFF000.	Il punto più alto del segmento della pila. Appello causa Segfault.
	0x7FFFFFFF0F8.	NULLO	vuoto	8	0x00 "
2.		Nome del file.	Char.	1+	"/Tmp/a.out"
			Char.	1	0x00.
...
		envino	Char.	1	0x00.
...
			Char.	1	0x00.
3.	0x7FFFFFFFE5E0.	envino	Char.	1	..
			Char.	1	0x00.
...
		ARGV.	Char.	1	0x00.
...
			Char.	1	0x00.
4.	0x7FFFFFFFE5BE.	ARGV.	Char.	1+	"/Tmp/a.out"
5.		Array di lunghezza casuale
6.		Dati per AUXV.	vuoto	48"
		AT_NULL.	Elf64_auxv_t.	16	{0,0}
...
		AUXV.	Elf64_auxv_t.	16
7.		aUXV.	Elf64_auxv_t.	16	Es.: (0x0e, 0x3e8)
		NULLO	vuoto	8	0x00.
...
		envino	Char *	8
8.	0x7FFFFFFE308.	envino	Char *	8	0x7FFFFFFFE5E0.
		NULLO	vuoto	8	0x00.
...
		aRGV.	Char *	8
9.	0x7FFFFFFFE2F8.	ARGV.	Char *	8	0x7FFFFFFFE5BE.
10.	0x7FFFFFFFE2F0.	argc.	lungo int.	8"	numero di argomenti + 1
11.		Variabili e argomenti locali, funzioni causate al principale
12.		Variabili locali Main.
13.	0x7FFFFFE1FC.	argc.	int.	4	numero di argomenti + 1
	0x7FFFFFFFE1F0.	aRGV.	char **	8	0x7FFFFFFFE2F8.
	0x7FFFFFFFE1E8.	envino	char **	8	0x7FFFFFFE308.
14.		Variabili delle funzioni locali

"- Non ho trovato le descrizioni dei campi nei documenti, ma la discarica è chiaramente visibile.

Per 32 bit non ha controllato, ma molto probabilmente è sufficiente solo per dividere le dimensioni in due.

1. Appello agli indirizzi, sopra il punto più alto, provoca Segfault.
2. Una stringa contenente il percorso verso il file eseguibile.
3. Array delle righe con variabili di ambiente
4. Array di stringhe con parametri della riga di comando
5. Una serie di lunghezza casuale. La sua selezione può essere disabilitata da comandi.
Systl -w kernel.randomize_va_space \u003d 0
Echo 0\u003e / proc / sys / kernel / randomize_va_space
6. Dati per il vettore ausiliario (ad esempio, la riga "x86_64")
7. Vettore ausiliario. Leggi di più sotto.
8. ARRAY NULL-TERMINALE DI PUNTO SULLE REWS DI AMBIENTE Variabili
9. Array zero-terminale dei puntatori alle corde dei parametri della riga di comando
10. Parola del tosaerba contenente il numero di parametri della riga di comando (uno degli argomenti delle funzioni "senior", consultare il paragrafo 11)
11. Clausola Variabili e argomenti, funzioni richiamate a Main (_Start, __ libc_start_main ..)
12. Inverato, dichiarato nel principale
13. Airgumenti delle funzioni principali
14. Movimento e argomenti di funzioni locali.

Vettore ausiliario
Per I386 e X86_64, non è possibile ottenere l'indirizzo del primo elemento del vettore ausiliario, ma il contenuto di questo vettore può essere ottenuto in altri modi. Uno di questi è fare riferimento all'area di memoria alla base della schiera dei puntatori alle file delle variabili di ambiente.
Questo dovrebbe essere simile a questo:
#Includere. #Includere. Int main (int Argc, char ** argv, char ** env) (Elf64_auxv_t * auxv; // x86_64 // elf32_auxv_t * auxv; // i386 while (* env ++! \u003d Null); // stiamo cercando L'inizio del vettore ausiliario per (AUXV \u003d (EF64_AUXV_T *) ENV; AUXV-\u003e A_TYPE! \u003d AT_NULL; AUXV ++) (Printf ("Addr:% P Tipo:% lx è: 0x% lx \\ n", AUXV , AUXV-\u003e A_TYPE, AUXV-\u003e A_UN .A_VAL);) printf ("\\ n (void *) (* argv) - (void *) auxv \u003d% p -% p \u003d% ld \\ n (vuoto *) ( AUXV) - (Void *) (& AUXV) \u003d% P-% P \u003d% ld \\ n ", (void *) (* argv), (void *) AUXV, (Void *) (* ARGV) - (vuoto *) AUXV, (Void *) (ARGV), (Void *) (& AUXV), (Void *) (ARGV) - (Void *) (& AUXV)); PrintF ("\\ n Copia ARGC:% D \\ n ", * ((int *) (argv - 1))); ritorno 0;)
Elf (32.64) Le strutture _auxv_t sono descritte in /usr/include/elf.h. Funzioni di rafforzamento in Linux-kernel / fs / binfmt_elf.c

Il secondo modo per ottenere il contenuto del vettore:
Hexdump / proc / self / auxv

La vista più memorabile è ottenuta impostando la variabile di ambiente LD_SHOW_AUXV.

Ld_show_auxv \u003d 1 ls
AT_HWCAP: BFEBFFFF // Caratteristiche del processore
AT_pagesz: 4096 // Dimensione della pagina di memoria
AT_CLKTCK: 100 // Aggiorna tempi di frequenza ()
AT_PHDR: 0x400040 // Informazioni di intestazione
AT_FENT: 56.
AT_PHNUM: 9.
AT_BASE: 0x7FD00B5BC000 // Indirizzo di interprete, intendo ld.so
AT_FLAGS: 0x0.
AT_ENTY: 0x402490 // Punto di ingresso nel programma
AT_UID: 1000 // Identificatori e gruppi utente
AT_EUID: 1000 // nominale ed efficiente
AT_GID: 1000.
AT_EGID: 1000.
AT_SECURE: 0 // Will Setuid Flag Sollevato
AT_RADOM: 0x7FFFF30BDC809 // Indirizzo 16 Byte casuali,
generato al lancio.
AT_SYSINFO_EHDR: 0x7FFF30BFF000 // puntatore alla pagina utilizzata per
// chiamate di sistema.
AT_EXECFN: / BIN / LS
AT_PLATFORM: X86_64.
A sinistra - il nome della variabile, direttamente a destra. Tutti i possibili nomi di variabili e la loro descrizione possono essere abbiglianti nel file Elf.h. (Costanti con prefisso AT_)

Ritorna dal principale ()
Dopo aver inizializzato il contesto del processo, il controllo viene trasmesso non in funzione principale (), ma alla funzione _Start ().
Principale () Cause da __libc_start_main. Quest'ultima funzione ha una caratteristica interessante - viene trasmessa a una funzione a una funzione che deve essere eseguita dopo il principale (). E questo puntatore viene trasmesso naturalmente attraverso lo stack.
In generale, gli argomenti __libc_start_main sono visualizzati in base al file ILBC-2.11 / SysDeps / IA64 / Elf / Start.s
/*
* Argomenti per __libc_start_main:
* OUT0: Main
* OUT1: ARGC
* OUT2: ARGV
* OUT3: init
* OUT4: Fini // funzione chiamata dopo Main
* OUT5: RTLD_FINI
* Out6: stack_end
*/
Quelli. Per ottenere l'indirizzo del puntatore Fini, è necessario spostarti in due parole del motore dall'ultima variabile locale principale.
Questo è quello che è successo (le prestazioni dipendono dalla versione del compilatore):
#Includere. void ** ret; Void * Leve; void foo () (Void (* BOO) (Void); // Puntatore alla funzione PrintF ("Stack Rewrite! \\ N"); boo \u003d (void (*) (vuoto)) lasciare; Fini ()) int principale (int Argc, char * argv, char * flp) (marchio int non firmato long int \u003d 0xbfbfbfbfbfbbfbfbfbfbfbfbf; // tag da cui lavoreremo ret \u003d (void **) (e Mark + 2); // Rimuovere le funzioni dell'indirizzo causato dopo il completamento (Fini) lasciare \u003d * ret; // Ricorda * ret \u003d (void *) foo; // patch return 0; // chiamando la funzione foo ())

Spero sia stato interessante.
In bocca al lupo

Grazie all'utente Xeor per la pubblicazione utile.