Tutorial di programmazione - pagina 3
Ti stai perdendo delle opportunità di trading:
- App di trading gratuite
- Oltre 8.000 segnali per il copy trading
- Notizie economiche per esplorare i mercati finanziari
Registrazione
Accedi
Accetti la politica del sito e le condizioni d’uso
Se non hai un account, registrati
Costruttori OOP - Tipi di costruttori che devi conoscere (nozioni di base per la padronanza)
Costruttori OOP - Tipi di costruttori che devi conoscere (nozioni di base per la padronanza)
In questo video discuteremo diversi tipi di Costruttori, il loro scopo e perché sono essenziali nella programmazione. Fornirò esempi e spiegherò il funzionamento in background dei costruttori. Ma prima di addentrarci, voglio consigliare uno strumento che utilizzo da anni chiamato PBS Studio. È un potente analizzatore di codice statico che aiuta a rintracciare i bug e migliorare la qualità del codice. Si integra facilmente con vari IDE e supporta linguaggi come C, C++, C# e Java. Puoi trovare il link per il download e persino scoprire modi per ottenerlo gratuitamente se sei uno studente. Torniamo ora al video.
Per iniziare, creiamo una classe chiamata "User" con membri pubblici: "firstName", "lastName", "age" e "email". Attualmente, assegniamo manualmente valori a queste proprietà per ogni utente che creiamo. Tuttavia, questo approccio diventa impraticabile con l'aumentare del numero di utenti.
Invece, esploreremo una soluzione migliore utilizzando i costruttori. I costruttori vengono utilizzati per costruire oggetti e automatizzano il processo di inizializzazione delle proprietà degli oggetti. Inizieremo spiegando il funzionamento in background dei Costruttori attraverso esempi.
A scopo dimostrativo, rimuoviamo il secondo utente e stampiamo le informazioni del primo utente. Eseguendo il programma, noterai che l'output mostra valori vuoti per firstName, lastName ed email e un numero grande o piccolo per age. Esploreremo perché ciò accade e l'assenza di eventuali errori.
Il motivo alla base di questo comportamento è il costruttore predefinito fornito da C++. Inizializza le proprietà con valori predefiniti, come il numero elevato che vediamo per l'età. Tuttavia, quando creiamo una variabile semplice, come "test", senza inizializzarla, riscontriamo un errore perché i tipi semplici non hanno costruttori predefiniti.
Esaminiamo ora le caratteristiche dei Costruttori. Innanzitutto, i costruttori hanno lo stesso nome della classe e nessun tipo restituito. In secondo luogo, devono essere inseriti nella sezione pubblica della classe. In terzo luogo, i costruttori predefiniti non hanno parametri. In quarto luogo, C++ genera automaticamente un costruttore predefinito se non ne crei uno. In quinto luogo, i costruttori parametrizzati ricevono i parametri per inizializzare le proprietà dell'oggetto. Infine, un costruttore predefinito viene richiamato automaticamente quando viene creato un oggetto di quella classe.
Implementiamo il nostro costruttore predefinito assegnando valori predefiniti alle proprietà. Con questa modifica, ogni volta che creiamo un utente, verrà richiamato il nostro costruttore predefinito. Ora, quando stampiamo le informazioni dell'utente, vedremo i valori predefiniti che abbiamo assegnato.
Andando avanti, esploriamo il secondo tipo di costruttore, il costruttore parametrizzato. A differenza del costruttore predefinito, il costruttore parametrizzato accetta valori specifici come parametri e li utilizza per istanziare le proprietà dell'oggetto. Fornirò un esempio di un costruttore parametrizzato che accetta parametri per firstName, lastName ed age.
Con questi parametri, possiamo assegnare i valori forniti alle proprietà corrispondenti. Questo ci consente di creare utenti con informazioni specifiche direttamente durante la creazione dell'oggetto.
Questo copre le basi dei costruttori e il loro utilizzo. Resta sintonizzato per ulteriori esempi e approfondimenti nei video futuri.
Funzioni e classi Friend in C++ (Programmazione per principianti)
Funzioni e classi Friend in C++ (Programmazione per principianti)
In questo video, sono entusiasta di insegnarti le funzioni degli amici e le classi degli amici in C++. Questo concetto di amicizia nella programmazione è simile all'amicizia nella vita reale. Proprio come i tuoi amici hanno accesso ad aree private della tua vita che altri non hanno, le funzioni di amicizia e le classi di amici nella programmazione orientata agli oggetti hanno accesso ai membri privati e protetti di una classe.
In questo video imparerai come e quando utilizzare le funzioni degli amici e le classi degli amici. Per dimostrare, utilizzeremo Visual Studio Community e ti presenterò anche un'eccellente estensione chiamata Visual Assist. Puoi trovare il link per il download nella descrizione qui sotto. Visual Assist è un assistente di codifica intelligente utilizzato da molti sviluppatori professionisti, in particolare per progetti di grandi dimensioni o sviluppo di giochi con motori come Unreal Engine. Migliora il completamento del codice, offre suggerimenti intelligenti per il refactoring, fornisce frammenti di codice e migliora la navigazione e la ricerca all'interno del progetto.
Ora, tuffiamoci nell'argomento delle funzioni degli amici. Per spiegare questo concetto, creiamo un problema e risolviamolo utilizzando le funzioni di amicizia. Creeremo una classe chiamata "EquilateralTriangle" per rappresentare un triangolo con tutti e tre i lati della stessa lunghezza. La classe avrà variabili private per la lunghezza del lato, la circonferenza e l'area. Aggiungeremo anche un metodo dell'incastonatore pubblico per impostare la lunghezza del lato e calcolare la circonferenza e l'area all'interno di tale metodo.
Tuttavia, se proviamo ad accedere ai membri privati al di fuori della classe, riscontreremo errori. Una soluzione è rendere pubblici i membri privati o creare getter pubblici, ma questo li espone a tutti. Invece, possiamo utilizzare le funzioni di amicizia per concedere in modo selettivo l'accesso. Creeremo una funzione globale chiamata "PrintResults" che stamperà la circonferenza e l'area del triangolo. Dichiarando questa funzione come amico della classe EquilateralTriangle, ottiene l'accesso ai membri privati.
Ma ricorda, scegli attentamente le funzioni dei tuoi amici ed evita un uso eccessivo per mantenere l'incapsulamento. Inoltre, in C++, puoi anche avere classi di amici. Se spostiamo la funzione "PrintResults" all'interno di una classe chiamata "Homework" e la rendiamo una public member function, possiamo dichiarare "Homework" come classe friend di "EquilateralTriangle". In questo modo, la classe "Homework" può accedere ai membri privati e protetti di "EquilateralTriangle".
È importante notare che l'amicizia nella programmazione non è reciproca o ereditata. Usa le funzioni e le classi di amici con giudizio e ricorda che l'ereditarietà e l'overload degli operatori implicano anche casi d'uso comuni per le funzioni di amici. Guarda il mio video sul sovraccarico dell'operatore (collegato nella descrizione) per ulteriori informazioni e un relativo esercizio a casa.
Spero che troverai questo video utile per comprendere e utilizzare le funzioni di amicizia e le classi di amici nei tuoi progetti di programmazione. Resta sintonizzato per contenuti più entusiasmanti e non dimenticare di dare un'occhiata all'estensione Visual Assist per Visual Studio!
Distruttori in programmazione: dimostrazione pratica
Distruttori in programmazione: dimostrazione pratica
In questo video, ti insegnerò i distruttori nella programmazione. Imparerai cosa sono i distruttori, come usarli e quando usarli. Assicurati di guardare l'intero video perché alla fine ho una sorpresa speciale per te. Prima di addentrarci nei distruttori, è importante comprendere i costruttori. Se non hai familiarità con i costruttori, guarda il mio video precedente collegato qui e nella descrizione.
I distruttori sono funzioni speciali richiamate quando un oggetto viene distrutto. Eseguono le attività di pulizia necessarie, come il rilascio di risorse come memoria o file detenuti dall'oggetto. Il mancato rilascio di queste risorse può ridurre le prestazioni, la stabilità e causare perdite di memoria.
Prima di iniziare a discutere dei distruttori, voglio presentarti uno strumento che amo usare chiamato PBS Studio. È un analizzatore di codice statico che mi aiuta a scrivere codice migliore senza bug. Analizza il tuo codice alla ricerca di potenziali problemi e bug, facendoti risparmiare tempo e denaro rilevando gli errori prima che entrino in produzione. È facile da integrare con gli IDE più diffusi e supporta più linguaggi di programmazione. Puoi scaricarlo dal link nella descrizione e provarlo gratuitamente. Se sei uno studente, controlla il loro sito Web per le opzioni gratuite.
Ora, approfondiamo i distruttori. Un distruttore è una funzione speciale con un nome identico al nome della classe, preceduto da una tilde (~). Non ha un tipo restituito, non riceve alcun parametro e dovrebbe essere inserito nella sezione pubblica della tua classe. Può esserci un solo distruttore per classe.
Per illustrare i distruttori, creiamo una classe chiamata "Book" con due proprietà: "title" e "author". Creeremo anche un costruttore e un distruttore. Ricorda, il distruttore dovrebbe deallocare tutte le risorse detenute dall'oggetto.
All'interno del costruttore, assegneremo i parametri passati alle proprietà corrispondenti. All'interno del distruttore, genereremo un messaggio che indica che il distruttore è stato invocato per un libro specifico.
Ora, creiamo alcuni oggetti libro per vedere quando vengono richiamati il costruttore e il distruttore. Eseguiremo il debug del programma e osserveremo l'ordine di invocazione.
Se la tua classe non coinvolge i puntatori, il compilatore gestirà automaticamente la deallocazione della memoria. Tuttavia, se stai lavorando con i puntatori, devi deallocare manualmente la memoria nel distruttore per evitare perdite di memoria. Ricorda di usare "delete[] arrayName" per gli array e imposta i puntatori su nullptr dopo la deallocazione.
Spero che questo video ti abbia aiutato a capire i distruttori e la loro importanza nella gestione delle risorse. Nel mio prossimo video, esploreremo i costruttori di copie, quindi rimanete sintonizzati.
Costruttori di copia C++ (tutorial per principianti + esempi pratici)
Costruttori di copia C++ (tutorial per principianti + esempi pratici)
Ciao a tutti, benvenuti nel mio canale. In questo video, ti insegnerò i costruttori di copie, che è un argomento importante ma confuso per i principianti. Prima di guardare questo video, assicurati di guardare il mio video precedente su diversi tipi di costruttori, inclusi costruttori predefiniti e parametrizzati (link nella descrizione). Inoltre, guarda il mio video su puntatori e array dinamici (link nella descrizione) in quanto ti aiuterà a capire meglio questo argomento.
In questo video, spiegherò tutto ciò che devi sapere sui costruttori di copie. I principianti spesso comprendono il concetto alla base dei costruttori di copie, ma hanno difficoltà a capire quando e come utilizzarli, nonché i potenziali bug ed errori che possono verificarsi. Tratterò tutti questi aspetti passo dopo passo.
Iniziamo esaminando il codice del mio video precedente. Ho creato una classe chiamata "Libro" con proprietà come titolo, autore e un puntatore chiamato "tariffe". Il puntatore "tariffe" rappresenta un array dinamico in cui gli utenti possono inserire valutazioni per il libro. C'è anche un "contatore di tassi" per tenere traccia della dimensione dell'array. Se non hai familiarità con i puntatori e gli array dinamici, ti consiglio di guardare il mio video su questo argomento (link nella descrizione).
Ho implementato un costruttore parametrizzato per la classe Book, che prende titolo e autore come parametri e crea un oggetto libro basato su quei valori. Ho anche incluso un distruttore, che è importante per liberare la memoria allocata dal costruttore. È fondamentale utilizzare un analizzatore di codice come PVS-Studio per rilevare errori nascosti e punti deboli nel codice. Personalmente raccomando di utilizzare PVS-Studio in quanto è efficace nel trovare errori e fornire suggerimenti per correggerli. Puoi scaricarlo gratuitamente utilizzando il link nella descrizione.
Ora concentriamoci sull'argomento dei costruttori di copie. Lo scopo di un costruttore di copie è creare un nuovo oggetto basato su un oggetto esistente. Ti permette di fare una copia di un oggetto e usarla per crearne uno nuovo. Per impostazione predefinita, C++ fornisce un costruttore di copie predefinito. Tuttavia, quando si lavora con i puntatori, è necessario creare un costruttore di copie personalizzato per evitare errori.
Senza un costruttore di copie personalizzato, l'utilizzo di puntatori può portare a eccezioni ed errori. Consideriamo il seguente scenario: voglio creare "Libro3" basato sui dati di "Libro1". Voglio copiare tutte le proprietà di "Book1" per creare "Book3". È qui che entra in gioco il costruttore di copie.
Per creare un costruttore di copie, segui queste regole:
Creiamo il costruttore di copie. Nel costruttore di copie, riceveremo l'oggetto originale come riferimento costante (const Book& original). Ciò impedisce qualsiasi modifica all'oggetto originale all'interno del costruttore di copie.
Ora, risolviamo un errore comune commesso dai principianti durante la creazione di un costruttore di copie. L'errore sta nel copiare direttamente il puntatore invece di allocare nuova memoria e copiare il contenuto. Se copiamo il puntatore, sia l'originale che la copia punteranno alla stessa locazione di memoria. Di conseguenza, quando viene richiamato il distruttore, tenterà di rilasciare la memoria due volte, causando errori.
Per risolvere questo problema, dobbiamo allocare nuova memoria per la copia e copiare il contenuto del puntatore originale. Invece di assegnare direttamente il puntatore, creeremo un nuovo array dinamico e copieremo gli elementi. Ciò garantisce che l'originale e la copia abbiano posizioni di memoria separate.
Seguendo queste linee guida, possiamo creare un corretto costruttore di copie che eviti errori relativi alla memoria.
Spero che questa spiegazione chiarisca il concetto di costruttori di copie e la loro importanza.
Codificalo da solo! Tetris - Programmazione da zero (Quick and Simple C++)
Codificalo da solo! Tetris - Programmazione da zero (Quick and Simple C++)
Ciao! Oggi intraprenderemo l'entusiasmante viaggio per creare la nostra versione di Tetris. Prima di approfondire la codifica, lascia che ti dia un'anteprima di ciò che costruiremo.
Come puoi vedere, abbiamo una classica forma di Tetris sullo schermo. Saremo in grado di ruotare queste forme, grazie al potere della codifica. Il gioco include il rilevamento delle collisioni, che assicura che i pezzi interagiscano correttamente tra loro. Se riusciamo a completare una linea posizionando strategicamente i pezzi casuali, questa scomparirà e il nostro punteggio aumenterà di conseguenza. Tuttavia, se non stiamo attenti e la pila di pezzi raggiunge la cima, il gioco è finito.
Ora, ti starai chiedendo perché ci stiamo concentrando sul motore di gioco piuttosto che sulla grafica. Sebbene l'estetica sia importante e possa attirare i giocatori, la vera essenza di un gioco risiede nel suo motore, la parte responsabile dell'implementazione del gameplay, della logica, delle regole, delle sfide e altro ancora. I motori grafici possono sempre essere aggiunti in seguito e puoi persino coinvolgere un artista per abbellire il tuo gioco. Ma per comprendere veramente lo sviluppo del gioco, devi cogliere i fondamenti della costruzione di un motore di gioco.
Per iniziare, abbiamo bisogno di alcune risorse di gioco. In Tetris, queste risorse sono le diverse forme chiamate "blocchi tetramino". Memorizzeremo queste forme come stringhe, il che ci renderà più facile visualizzarle. Ci sono sette forme comuni usate in Tetris, e le rappresenteremo usando caratteri come punti (.) per spazi vuoti e X maiuscola per la forma stessa. Disponendo questi caratteri, creiamo stringhe che rappresentano visivamente le forme.
Ora, invece di utilizzare array multidimensionali per rappresentare le forme 2D, utilizzeremo un array unidimensionale e manipoleremo gli indici utilizzando semplici calcoli matematici. Questo approccio ci consente di gestire le rotazioni e i riflessi delle forme in modo più efficiente. Useremo formule per determinare gli indici appropriati per ogni rotazione. Ad esempio, moltiplicando la coordinata X per 4, possiamo ottenere l'indice desiderato per una rotazione di 90 gradi. Questa tecnica ci salverà dalla creazione di risorse separate per ogni possibile variazione di forma.
Oltre ai blocchi di tetramino, abbiamo bisogno anche di un campo da gioco. Definiremo le dimensioni del campo utilizzando le variabili per larghezza e altezza. In questo caso, andremo con una dimensione del campo di 12 celle di larghezza e 18 celle di altezza. Per rappresentare gli elementi del campo di gioco, useremo un array di caratteri senza segno. Ad ogni cella verrà assegnato un valore per indicarne il contenuto, come spazio vuoto, parte di una forma o muri di confine.
Per visualizzare il nostro gioco, utilizzeremo il prompt dei comandi come buffer dello schermo. Creando un array con le dimensioni della finestra del prompt dei comandi, possiamo disegnare i nostri elementi di gioco su di esso. Useremo caratteri specifici per rappresentare diversi elementi del gioco, come le forme, gli spazi vuoti e le mura di cinta. Quindi, mostreremo il contenuto dell'array nella schermata del prompt dei comandi.
Ora parliamo del loop di gioco. I loop di gioco sono componenti vitali di qualsiasi motore di gioco in quanto controllano la sequenza degli elementi del gioco. Nel caso di Tetris, il nostro ciclo di gioco gestirà il tempo, l'input dell'utente, la logica del gioco e il rendering dell'output.
Il tempismo è fondamentale per garantire un gameplay coerente su sistemi diversi. Vogliamo che il gioco funzioni allo stesso ritmo, indipendentemente dalla velocità del computer. Useremo meccanismi di temporizzazione per controllare la velocità con cui le forme cadono e il gioco si aggiorna.
Successivamente, affronteremo l'input dell'utente. Dal momento che stiamo creando una semplice versione da riga di comando di Tetris, non faremo affidamento su input basati su eventi. Invece, gestiremo l'input dell'utente di base, come i tasti freccia o altri tasti designati.
In questo codice, implementeremo la gestione dell'input da tastiera per un gioco, concentrandoci in particolare su quattro tasti: la freccia sinistra, la freccia destra, la freccia giù e il tasto "Z" per ruotare il pezzo di gioco.
Per ottenere lo stato attuale dei tasti premuti dall'utente, utilizzeremo la funzione "get async key state". Iterando attraverso un array che rappresenta lo stato dei tasti, possiamo determinare se ogni tasto è attualmente premuto o meno. Questa funzione restituisce un valore booleano: vero se il tasto è premuto e falso se non lo è. Per verificare lo stato di una chiave specifica, utilizziamo un'espressione di stringa costante che rappresenta i codici chiave virtuali per ciascuna chiave.
Controllando lo stato di questi quattro tasti, possiamo creare un array che contiene valori veri o falsi che indicano se ogni tasto è premuto o meno. Questo semplifica il processo e ci fornisce un array che rappresenta lo stato corrente delle chiavi.
Consideriamo il tasto sinistro come esempio. Quando l'utente preme il tasto sinistro, dobbiamo verificare se il pezzo di gioco può stare a sinistra della sua posizione attuale. Per fare questo, utilizziamo una funzione chiamata "does piece fit", che considera il pezzo corrente, la sua rotazione e la posizione X corrente. Sottraendo 1 dalla posizione X corrente, possiamo determinare se il pezzo si adatta a sinistra. Se va bene, aggiorniamo la posizione X corrente di conseguenza.
Allo stesso modo, per la chiave giusta, eseguiamo un controllo simile per vedere se il pezzo può stare a destra della sua posizione attuale. Se possibile, aggiorniamo di conseguenza la posizione X corrente.
Quando l'utente preme il tasto giù, dobbiamo gestire il movimento verticale del pezzo. Poiché la posizione in alto a sinistra del campo di gioco è sempre (0, 0), possiamo semplicemente incrementare la posizione Y per spostare il pezzo verso il basso. Eseguiamo controlli per garantire che lo spostamento del pezzo a sinistra, a destra o in basso lo mantenga all'interno dei confini del campo di gioco.
Per ottimizzare il codice, possiamo sostituire le istruzioni if nidificate con operatori AND logici. Questo semplifica il codice e ne migliora la concisione. Inoltre, utilizziamo istruzioni condizionali per aggiungere o sottrarre 1 dalla posizione X corrente in base al risultato della condizione, semplificando ulteriormente il codice. La stessa ottimizzazione viene applicata quando si gestisce la rotazione del pezzo quando l'utente preme il tasto "Z".
In Tetris, il gioco costringe periodicamente il pezzo a scendere ogni pochi decimi di secondo, simulando la gravità. Raggiungiamo questo obiettivo utilizzando il contatore di tick del gioco. Inizialmente, il pezzo cade lentamente, ma man mano che il gioco procede, riduciamo il tempo tra ogni caduta del pezzo, rendendo il gioco più veloce e più impegnativo. Accumulando i tick di gioco e confrontandoli con la velocità attuale, determiniamo quando forzare il pezzo verso il basso. Ciò fa sì che il pezzo cada a intervalli regolari, creando l'effetto della gravità nel gioco.
Per bloccare il pezzo corrente nel campo di gioco, aggiorniamo l'array field con i valori dell'array tetramino. Questo viene fatto iterando ogni elemento dell'array tetramino e aggiornando la posizione corrispondente nell'array field. Se un elemento nell'array tetramino è una "X", incrementiamo il valore corrispondente nell'array field di 1. Questo contrassegna quella posizione come occupata dal pezzo corrente.
Quando si forma una linea nel campo di gioco, vogliamo indicarla visivamente al giocatore. Sostituiamo la linea con un pennarello speciale o eseguiamo qualsiasi altro effetto visivo per indicare il completamento della linea.
Dopo aver indicato visivamente la linea completata, dobbiamo gestire la cancellazione della linea e l'aggiornamento del campo di gioco di conseguenza. Scorriamo ogni riga del campo di gioco partendo dal basso e controlliamo se la riga è piena. Se una riga è piena, la cancelliamo impostando tutti i suoi elementi su 0. Quindi spostiamo tutte le righe sopra di essa verso il basso di una posizione per riempire la riga cancellata. Questo processo viene ripetuto finché tutte le righe riempite non sono state cancellate.
Per tenere traccia del punteggio del giocatore, lo incrementiamo ogni volta che una linea viene cancellata. Il punteggio può essere basato sul numero di linee cancellate o può avere un sistema di punteggio più complesso a seconda del design del gioco.
Per gestire le condizioni di game over, dobbiamo controllare se il pezzo attuale può stare nella sua posizione iniziale in cima al campo di gioco. Se non riesce a entrare, il gioco è finito e interrompiamo il ciclo di gioco o attiviamo qualsiasi azione di game over necessaria.
Infine, per gestire il ciclo di gioco, utilizziamo un timer o un meccanismo simile che attiva una funzione di aggiornamento a intervalli regolari. Questa funzione gestisce l'aggiornamento dello stato del gioco, incluso il controllo dell'input dell'utente, lo spostamento del pezzo verso il basso e l'esecuzione delle azioni necessarie in base allo stato del gioco corrente.
In sintesi, questo codice implementa la gestione dell'input da tastiera per un gioco, concentrandosi in particolare su tasti come i tasti freccia e il tasto "Z". Controlla lo stato di questi tasti, gestisce il movimento del pezzo di gioco di conseguenza, implementa la gravità e il blocco del pezzo, cancella le linee completate, aggiorna il campo di gioco, tiene traccia del punteggio del giocatore e controlla le condizioni di game over. Il ciclo di gioco assicura che lo stato del gioco venga aggiornato a intervalli regolari, creando un'esperienza di gioco dinamica e interattiva.
CORSO COMPLETO C++ per principianti (Impara C++ in 10 ore)
CORSO COMPLETO C++ per principianti (Impara C++ in 10 ore)
Questo è un corso completo di programmazione C++. Consiste in molte lezioni il cui obiettivo è portarti dal livello di programmazione principiante a quello avanzato. Consiglio di guardare l'intero video perché le lezioni successive richiedono la conoscenza di quelle precedenti.
Contenuti:00:00:00 – Obiettivi del corso
00:01:31 – Fallo prima di iniziare il corso
00:02:41 - Introduzione al C++ (Cos'è il C++? Che tipo di app puoi creare con il C++? Perché è stato creato il C++?)
00:06:39 - Cos'è il codice sorgente, il codice oggetto, il compilatore, l'algoritmo?
00:08:42 - Visual Studio 2019 – Creazione di un primo progetto (setup)
00:11:32 - Spiegazione delle basi di Visual Studio 2019 e primo programma "Hello World"
00:29:51 - Introduzione alle variabili
00:44:36 – Regole per nominare le variabili
00:52:15 - Tipi di dati in C++ e come utilizzare l'operatore sizeof
01:01:58 - Overflow del tipo di dati
01:05:00 - Cos'è la tabella ASCII
01:09:50 - Programma semplice e divertente per cifrare parole in ASCII
01:18:12 - Istruzione If/else (costruisci un programma che controlla i numeri pari/dispari + spiegazione del diagramma di flusso)
01:35:52 - Istruzione if/else nidificata (costruisci un programma che determina il tipo di triangolo + diagramma di flusso)
01:55:50 - Operatori in C++ (operatori aritmetici, relazionali, logici, di assegnazione)
02:21:02 - Scambiare i valori di due variabili con o senza una terza variabile
02:29:20 - Crea un'applicazione Calcolatrice BMI + diagramma di flusso
02:49:55 - Operatore ternario (condizionale) (costruisci un'app per indovinare)
03:01:00 - Dichiarazione switch/case parte 1 (Build Calculator app)
03:26:36 - Dichiarazione switch/case parte 2 (creare un programma che controlli il numero di giorni in un mese)
03:39:35 - Ciclo while parte 1 + esempio ciclo infinito
03:53:39 - Ciclo while parte 2 (costruisci un programma per contare le cifre di un numero)
04:12:39 - Ciclo while parte 3 (costruisci un programma per invertire le cifre di un numero)
04:25:25 - Do while loop (Programma per la convalida del PIN)
04:39:09 - Qual è la differenza tra ciclo While e ciclo Do While
04:40:34 - Ciclo for (costruisci un programma per calcolare il fattoriale di un numero)
04:58:12 - Cicli nidificati (annidamento do while loop e for loop)
05:11:08 - Ciclo for nidificato (crea app per tabelle di moltiplicazione)
05:21:45 – Programma per disegnare forme rettangolari
05:33:05 – Programma per disegnare triangoli e triangoli capovolti/invertiti
05:44:30 – Introduzione alle funzioni
05:56:02 – Funzioni con parametri/argomenti (multiple e default)
06:11:42 - Dichiarazione di ritorno della funzione (costruisci un programma per controllare i numeri primi)
06:37:39 - Sovraccarico delle funzioni
06:48:06 - Crea un'app bancomat
07:03:03 - Funzioni e modelli generici
07:14:30 – Ricorsione e funzioni ricorsive
07:30:01 – Introduzione a OOP, cosa sono le classi e gli oggetti
07:42:06 - Costruttori OOP e metodi di classe
07:57:10 – Incapsulamento OOP, GIT: https://github.com/TrueCodeBeauty/EncapsulationCpp
08:08:31 - Ereditarietà OOP, GIT: https://github.com/TrueCodeBeauty/InheritanceCpp
08:24:59 – Polimorfismo OOP, GIT: https://github.com/TrueCodeBeauty/PolymorphismCpp
08:40:04 - Introduzione ai puntatori
08:51:14 - Puntatori vuoti
09:06:27 - Puntatori e array
09:19:18 - Restituisce più valori da una funzione utilizzando i puntatori
09:34:50 - Array dinamici, crea/modifica array in fase di esecuzione
09:48:35 - Array dinamici multidimensionali, array bidimensionali
10:07:00 - Rilevamento di errori nel codice tramite PVS Studio
10:17:19 - Spiegazione delle perdite di memoria
10:26:25 - Errori
FUNZIONI C++ (2020) - Cosa sono le funzioni?
FUNZIONI C++ (2020) - Cosa sono le funzioni? TUTORIAL DI PROGRAMMAZIONE
Benvenuti nel primo video del mio canale! Se sei un principiante in C++, assicurati di dare un'occhiata alla mia playlist su C++ per principianti, dove puoi trovare concetti importanti che devi capire e conoscere per lavorare con C++. In questo video parleremo delle funzioni C++, essenziali per diventare un buon programmatore non solo in C++ ma nella maggior parte dei linguaggi di programmazione.
Prima di iniziare, iscriviti al mio canale e fai clic sull'icona della campana per ricevere notifiche quando pubblicherò il mio prossimo video. Se sei interessato a vedere i contenuti dietro le quinte e come appare davvero la vita degli sviluppatori, seguimi su Instagram e Twitter attraverso i miei account "CodeBeauty".
Ora, tuffiamoci nell'argomento delle funzioni. Una funzione è un blocco di codice raggruppato per risolvere un problema specifico o eseguire un'attività specifica. Il codice all'interno di una funzione viene eseguito solo quando la funzione viene chiamata o invocata. Ogni programma C++ contiene almeno una funzione, che è la funzione principale. L'esecuzione del programma inizia dalla prima riga della funzione principale e termina all'ultima riga o quando si incontra un'istruzione return (parleremo delle istruzioni return più avanti in questo corso).
Per creare la tua funzione, ci sono alcune cose che devi sapere. Innanzitutto, è necessario specificare il tipo restituito della funzione. Per ora, useremo il tipo restituito "void", il che significa che la funzione non restituisce nulla. Successivamente, dai un nome alla tua funzione. All'interno delle parentesi, puoi definire qualsiasi argomento o parametro che la tua funzione riceve. In questo caso non avremo argomenti, quindi le parentesi sono vuote. Infine, definisci il corpo della funzione tra parentesi graffe.
Nel nostro esempio, abbiamo creato una funzione chiamata "funzione" con un tipo di ritorno void e nessun argomento. All'interno del corpo della funzione, usiamo l'istruzione "cout" per visualizzare "Hello from function" e aggiungere una linea di fine. Tuttavia, la semplice creazione della funzione non ne esegue il codice. Per eseguire la funzione, è necessario invocarla o chiamarla. Nel nostro caso, chiamiamo la funzione dopo l'istruzione "cout" nella funzione principale digitando il suo nome seguito da parentesi.
Dopo aver compilato ed eseguito il programma, vedrai l'output "Hello from main" seguito da "Hello from function". Questo perché la funzione principale viene eseguita per prima, quindi la funzione che abbiamo creato viene eseguita quando viene invocata.
Per rendere il codice più leggibile, si consiglia di dichiarare e definire le funzioni separatamente. La dichiarazione include il tipo restituito, il nome della funzione e qualsiasi parametro e deve essere posizionata prima della funzione principale. La definizione, che contiene il corpo della funzione, è posta dopo la funzione principale. In questo modo, se qualcun altro sta leggendo il tuo codice, può facilmente navigare verso la funzione specifica che deve comprendere.
Ricorda che le funzioni rendono il tuo codice riutilizzabile. Invece di scrivere lo stesso codice più volte, puoi scriverlo una volta all'interno di una funzione e richiamare quella funzione ogni volta che ne hai bisogno. Questa pratica aiuta a ridurre la ridondanza e semplifica la gestione del codice.
Nei video futuri, esploreremo le funzioni in modo più dettagliato. Non dimenticare di iscriverti al mio canale e abilitare le notifiche per rimanere aggiornato con i prossimi contenuti. Grazie per aver guardato e ci vediamo nel prossimo video!
FUNZIONI C++ (2020) - Cos'è il parametro/argomento della funzione (multiplo, predefinito) TUTORIAL DI PROGRAMMAZIONE
FUNZIONI C++ (2020) - Cos'è il parametro/argomento della funzione (multiplo, predefinito) TUTORIAL DI PROGRAMMAZIONE
Ciao a tutti! Bentornati sul mio canale. Se sei un principiante del C++, sono contento che tu sia qui. Prima di approfondire l'argomento di oggi, voglio ricordarti di dare un'occhiata alla mia playlist C++ per principianti. Copre concetti essenziali e include molti esercizi per aiutarti a esercitarti. Inoltre, non dimenticare di iscriverti al mio canale e di fare clic sull'icona della campana per ricevere notifiche ogni volta che pubblico un nuovo video. Puoi anche seguirmi sui miei profili di social media, CodeBeauty Instagram e Twitter, per dare una sbirciatina alla vita di uno sviluppatore. Va bene, senza ulteriori indugi, passiamo alla lezione di oggi.
In questo video, voglio discutere i parametri o gli argomenti della funzione C++. Quindi, cosa sono esattamente i parametri e gli argomenti? Se non hai guardato il mio video precedente sulle funzioni C++, ti consiglio di provarlo (link fornito). A volte, una funzione deve ricevere un valore o una variabile specifici per eseguire una particolare attività. Questi valori o variabili sono chiamati parametri.
Ora impariamo come creare una funzione che accetti parametri in C++. Per fare ciò, definiamo una funzione con un tipo di ritorno void. Chiamiamo la funzione "introduceMe". All'interno delle parentesi, specifichiamo i parametri che la funzione riceverà. Il corpo della nostra funzione sarà racchiuso tra parentesi graffe.
Per definire un parametro, iniziamo dichiarando il tipo del parametro, seguito dal suo nome. Nel nostro caso vogliamo passare alla funzione il nome del nostro utente, quindi il parametro sarà di tipo stringa. Chiameremo il parametro "nome". La funzione presenterà quindi il nostro utente stampando "My name is" seguito dal nome fornito.
Per invocare o chiamare la nostra funzione, usiamo semplicemente il suo nome, "introduceMe". Poiché la nostra funzione richiede un argomento (il parametro name), dobbiamo passare un valore quando chiamiamo la funzione. In questo caso, passiamo il nome "Selena" come argomento.
Quando eseguiamo il programma, la funzione introdurrà correttamente l'utente con il nome fornito. Stamperà "My name is Selena" come previsto.
Se vogliamo introdurre più utenti, possiamo chiamare nuovamente la funzione con argomenti diversi. Ad esempio, possiamo copiare la riga di chiamata e passare un nome diverso, come "Anna". La funzione presenterà quindi entrambi gli utenti di conseguenza.
Ora, esploriamo il passaggio di più argomenti a una funzione. Per fare ciò, separiamo i parametri con le virgole. Oltre al parametro name, aggiungiamo altri due parametri: city (di tipo string) ed age (di tipo int). Modificheremo la funzione per includere anche informazioni sulla città e l'età dell'utente.
All'interno della funzione, useremo "cout" di C++ per stampare la città e l'età dell'utente insieme al suo nome. Struttureremo l'output come segue: "Vengo da [città] e ho [età] anni".
Quando invochiamo la funzione, passiamo i valori per tutti e tre i parametri: nome, città ed età. Ad esempio, possiamo chiamare la funzione e passare "Selena" come nome, "Mosca" come città e 25 come età. La funzione presenterà all'utente tutte le informazioni fornite.
Possiamo ripetere il processo per un secondo utente. Passiamo "Anna" come nome, "New York" come città e 27 come età. Quando eseguiamo il programma, vedremo che entrambi gli utenti sono stati presentati con i rispettivi dettagli.
Successivamente, esploriamo i parametri predefiniti. A volte, potresti voler definire un valore predefinito per un parametro. Questo valore verrà utilizzato se non viene fornito alcun argomento per quel parametro quando si chiama la funzione.
Per specificare un valore predefinito, lo assegniamo durante la dichiarazione del parametro. Ad esempio, impostiamo il valore predefinito per il parametro "età" a 18. Ora, se chiamiamo la funzione senza fornire un'età, assumerà il valore predefinito.
Invochiamo la funzione per un terzo utente, passando solo il nome e la città, ma omettendo l'età. Come previsto, la funzione introdurrà l'utente con il valore di età predefinito di 18 anni.
Questo conclude la nostra discussione sui parametri e gli argomenti delle funzioni C++. Spero che questo video ti sia stato utile e che tu abbia una solida conoscenza di come lavorare con i parametri delle funzioni in C++. Se hai domande o hai bisogno di ulteriori chiarimenti, lascia un commento qui sotto e sarò felice di aiutarti. Resta sintonizzato per altri tutorial su C++ e non dimenticare di mettere mi piace e condividere questo video se lo hai trovato utile. Grazie per la visione e buona programmazione!
FUNZIONI C++ (2020) - Funzioni return statement, Come controllare i numeri primi
FUNZIONI C++ (2020) - Funzioni return statement, Come controllare i numeri primi TUTORIAL DI PROGRAMMAZIONE
Ciao a tutti, benvenuti nel mio canale. In questo video, voglio discutere le istruzioni return e restituire i tipi di funzioni in C++. Se sei un principiante, assicurati di dare un'occhiata al mio corso C++ per principianti, che fornisce esempi utili per aiutarti a iniziare con l'apprendimento del C++. Non dimenticare di iscriverti al mio canale e di attivare la campanella delle notifiche per rimanere aggiornato sui nuovi video. Inoltre, se sei interessato a diventare uno sviluppatore e ottenere informazioni sulla vita dello sviluppatore, seguimi su Instagram e Twitter su @truecodebeauty (link nella descrizione del video). Senza ulteriori indugi, tuffiamoci nell'argomento di oggi.
Un tipo restituito di una funzione può essere qualsiasi tipo di dati, inclusi int, float, bool, char, double o anche tipi di dati definiti dall'utente. Può anche essere void, a indicare che la funzione non restituisce nulla. Nei video precedenti, ho spiegato che una funzione è un blocco di codice progettato per eseguire un'attività specifica. Le funzioni possono essere classificate in due tipi: quelle che restituiscono un valore e quelle che non lo fanno.
Le funzioni che non restituiscono un valore in genere eseguono un'azione specifica, ad esempio la visualizzazione di un menu all'utente. D'altra parte, le funzioni che restituiscono un valore vengono utilizzate per eseguire calcoli o operazioni e fornire un risultato. È importante notare che una funzione può restituire solo un valore e, una volta incontrata l'istruzione return, l'esecuzione della funzione si interrompe.
Per illustrare l'importanza delle funzioni, consideriamo un esempio senza utilizzare le funzioni. Creeremo un programma per determinare se un numero è primo o no. Un numero primo è divisibile solo per uno e per se stesso. Innanzitutto, chiederemo all'utente di inserire un numero. Quindi, ripeteremo tutti i numeri compresi tra 2 e il numero immesso dall'utente meno 1. Se il numero è divisibile per uno di questi valori, non è primo. Altrimenti è ottimo. Infine, mostreremo il risultato.
Ora eseguiamo il refactoring del programma utilizzando le funzioni per rendere il codice più leggibile e riutilizzabile. Creeremo una funzione chiamata "isPrimeNumber" che accetta un argomento intero e restituisce un valore booleano che indica se il numero è primo o meno. All'interno della funzione, implementeremo la stessa logica di prima, verificando la divisibilità e impostando un flag di conseguenza. Infine, restituiremo il valore del flag.
Usando le funzioni, possiamo incapsulare la logica per determinare i numeri primi, rendendo il codice più facile da capire e riutilizzare.
FUNZIONI C++ (2020) - Che cos'è il sovraccarico delle funzioni? TUTORIAL DI PROGRAMMAZIONE
FUNZIONI C++ (2020) - Che cos'è il sovraccarico delle funzioni? TUTORIAL DI PROGRAMMAZIONE
Ciao a tutti! Bentornati sul mio canale. Nel video di oggi, approfondiremo il concetto di sovraccarico di funzioni in C++. L'overload delle funzioni ci consente di creare più funzioni con lo stesso nome ma parametri diversi. Quindi, esploriamo cos'è il sovraccarico di funzioni e come funziona.
Per iniziare, apriamo il nostro Visual Studio e creiamo una funzione chiamata "somma". Inizieremo definendo il tipo restituito della nostra funzione, che sarà un numero intero. Se non hai familiarità con i tipi di ritorno, ti consiglio di guardare il mio video sull'argomento (link fornito). Successivamente, specificheremo il nome della nostra funzione come "somma" e dichiareremo due parametri. Entrambi i parametri saranno di tipo intero e li chiameremo rispettivamente "a" e "b".
Ora creiamo un'altra funzione con lo stesso nome, "sum", ma questa volta con un tipo di ritorno double. Dichiareremo due parametri di tipo double, denominati "a" e "b".
Inoltre, creiamo una terza funzione chiamata "sum" con un tipo di ritorno float. Questa volta passeremo tre parametri, tutti di tipo float. Li chiameremo rispettivamente "a", "b" e "c".
Dopo aver dichiarato le nostre funzioni, notiamo che sono sottolineate, indicando che mancano le loro definizioni. Procediamo fornendo le definizioni per ogni funzione. Inizieremo con la prima funzione che restituisce un numero intero.
All'interno delle parentesi graffe, definiremo una variabile chiamata "result" di tipo int. Gli assegneremo il valore di "a + b", che rappresenta la somma dei due parametri. Infine, utilizzeremo la parola chiave "return" per restituire il valore di "result" dalla funzione.
In alternativa, invece di creare una variabile separata, possiamo restituire direttamente la somma di "a" e "b" senza assegnarla a una variabile. Questo può rendere il codice più breve e più leggibile.
Successivamente, definiamo la seconda funzione che restituisce un double. Copiamo la dichiarazione, aggiungiamo le parentesi graffe e all'interno useremo la parola chiave "return" seguita da "a + b". Poiché i parametri sono di tipo double, la somma verrà eseguita utilizzando la doppia precisione.
Ora, definiamo la terza funzione che restituisce un float. Copiamo la dichiarazione, aggiungiamo le parentesi graffe e all'interno useremo la parola chiave "return" seguita da "a + b + c". Anche in questo caso, poiché tutti i parametri sono di tipo float, la somma verrà eseguita di conseguenza.
Per testare le nostre funzioni, le invocheremo nella funzione "main". Useremo l'istruzione "cout" per visualizzare i risultati. Cominciamo chiamando la prima funzione, "sum", e passando due valori interi, come 4 e 3. Produrremo il risultato usando "cout" e finiremo la linea.
Quando eseguiamo il programma, possiamo aspettarci di vedere il risultato della somma di 4 e 3, che dovrebbe essere 7. Se il programma viene eseguito correttamente, abbiamo testato la nostra prima funzione.
Successivamente, testiamo la seconda funzione chiamando "sum" e passando due valori double, come 4.4 e 3.3. Di nuovo, genereremo il risultato usando "cout" e finiremo la riga.
Quando eseguiamo il programma, dovremmo vedere il risultato della somma di 4.4 e 3.3, che dovrebbe essere 7.7. Se l'output è corretto, abbiamo testato con successo la nostra seconda funzione.
Infine, testiamo la terza funzione chiamando "sum" e passando tre valori float, come 4.4, 3.3 e 2.2. Produrremo il risultato usando "cout" e finiremo la riga.
L'esecuzione del programma dovrebbe visualizzare il risultato della somma 4.4, 3.3 e 2.2, che dovrebbe essere la somma corretta. Verificare l'output utilizzando una calcolatrice, se necessario.
In sintesi, quello che abbiamo dimostrato qui è il sovraccarico di funzioni. Abbiamo creato tre funzioni con lo stesso nome, "somma", ma con parametri e tipi restituiti diversi. La prima funzione accetta due interi, la seconda due doppi e la terza tre float. Quando invochiamo queste funzioni, il compilatore determina la funzione appropriata da chiamare in base agli argomenti forniti.
L'overload delle funzioni ci consente di scrivere codice più conciso e leggibile utilizzando lo stesso nome per le funzioni che eseguono compiti simili. Non è necessario creare funzioni separate con nomi diversi per ogni variazione.
Spero che tu ora comprenda il concetto di sovraccarico di funzioni e come possa essere utile in C++. Se questo video ti è piaciuto, iscriviti al mio canale e clicca sulla campanella per ricevere le notifiche per i video futuri. Puoi anche seguirmi sulle mie altre piattaforme di social media (link forniti nella descrizione).
Grazie per aver guardato e ci vediamo nel mio prossimo video. Ciao!