C++ Programming

00:00:00ben ciao internet e benvenuti nel mio

00:00:01C ++ esercitazione programmazione in questo

00:00:03tutorial ho intenzione di insegnare l’intera

00:00:05C ++ linguaggio di programmazione in un unico video

00:00:08la descrizione sotto il video

00:00:09si sta andando a vedere i link a tutti i

00:00:10le singole parti in modo che dovrebbero aiutarvi

00:00:12farlo esattamente quello che vuoi e io sono

00:00:14non andare a perdere tempo che copre

00:00:16installazione, se voi ragazzi mi vogliono

00:00:17copertura che basta lasciare un commento in basso

00:00:19qui sotto e lo farò più tardi e quindi ho una

00:00:20molto da fare quindi cerchiamo di entrare in esso

00:00:22Va bene così quello che ho qui a sinistra

00:00:24lato dello schermo è una base TextEdit

00:00:26o quello che ho qui sul lato destro della

00:00:27schermo è un terminale tutto sta andando

00:00:29ad essere esattamente lo stesso, purché si

00:00:31utilizzare G plus plus per compilare i programmi

00:00:33non importa se siete su Mac Windows o su

00:00:36un sistema operativo Linux in modo molto

00:00:39prima cosa che andremo a fare qui è

00:00:40coprire i commenti questo è un commento solo

00:00:43come molte altre lingue è possibile creare

00:00:45un commento solo mettendo due trattini e

00:00:47poi quello che vuoi e se si vuole un

00:00:48multi-riga di commento si può semplicemente digitare

00:00:51multi-linea e quindi chiudere che off

00:00:53Sebbene ci sia commentando c ++ prima

00:00:56cosa che andremo a fare è includere

00:00:58alcune librerie esterne che sto per avere

00:01:00alcune funzioni che si sta andando a voler

00:01:02per usare così questo ha intenzione di permettere a noi

00:01:04utilizzare funzione chiamata C fuori e un’intera

00:01:07mucchio di altre cose diverse che siete

00:01:08andando a vedere qui in un secondo che sarà

00:01:09utilizzato per i vettori questo sarà usato per

00:01:11stringhe e poi questo sarà utilizzato per

00:01:13I / O file ora tutto il codice sta andando

00:01:17essere contenuto all’interno di una conduttura

00:01:19funzione come questa e poi si sta andando

00:01:21di avere una parentesi graffa e poi si

00:01:22avere una parentesi graffa di chiusura ora all’interno

00:01:24di qui si potrebbe chiamare la funzione C

00:01:27in alternativa, utilizzando C fuori o STD C fuori come

00:01:32questo quello che voglio fare è sbarazzarsi di

00:01:34questa parte e come mi libero di questo è

00:01:36proprio qui a destra dopo l’inclusione

00:01:38dichiarazione così ho intenzione di digitare utilizzando

00:01:40namespace STD mi impediscono di dover

00:01:43tipo che su ogni singolo Adesso se

00:01:45si voleva fare un mondo di base ciao

00:01:47tipo di istruzione qui tutto stiamo andando

00:01:49di avere a che fare è digitare Ciao mondo

00:01:50utilizzando C quale fornisce in uscita il testo

00:01:54abbiamo qui e un ritorno a capo

00:01:56ogni volta che tipo nello stesso staffe

00:01:58che si vede proprio lì e Ndele che è per

00:02:01il ritorno a capo e questo qui

00:02:02dicendo siamo andati a mettere questo sul nostro

00:02:04schermare l’altra cosa che dobbiamo fare

00:02:06qui è chiamata ritorno pari a zero sei sempre

00:02:09intenzione di fare questo e lo zero sta per la

00:02:11esecuzione ha attraversato

00:02:12perfettamente bene così solo per mantenere

00:02:13tutto semplice salto qui nel

00:02:15terminale e questo è il comando che sono

00:02:17che verrà usata per eseguire questo si chiama vedere

00:02:18Tut e assicurarsi che con i vostri programmi C ++

00:02:21li finisce sempre con CP PXZ

00:02:23estensione poi proprio qui sto dicendo

00:02:25che voglio utilizzare la versione 11 di C ++

00:02:27poi ho intenzione di compilare questo e poi

00:02:30per eseguirlo ho intenzione di mettere periodo per esso

00:02:32tagliare un punto se siete su Windows

00:02:34sarebbe solo digitare una e si può vedere

00:02:36ciao mondo viene stampato rosso così così

00:02:38la prossima cosa che vogliamo discutere qui

00:02:39sono variabili e tipi di dati

00:02:41ora le variabili iniziano con una lettera e

00:02:43può contenere lettere, ovviamente aggiuntivi

00:02:45numeri o underscore ma devono

00:02:47Cominciamo con la lettera e qui siamo

00:02:49andando a creare in realtà una costante

00:02:51variabile che sta per essere di tipo

00:02:53datatype doppia che significa che

00:02:56contiene numeri in virgola mobile o

00:02:58decimali e qui stiamo andando a

00:03:00dare il valore di 3.14159265 35 e

00:03:06ancora una volta costante essendo qui solo

00:03:08significa che questo valore non può essere modificato

00:03:10e normalmente ogni volta che si definisce

00:03:12variabili costanti si fanno i loro nomi

00:03:15in tutti i casi superiori altri tipi di dati che

00:03:17sono a disposizione di sei caratteri

00:03:19che contengono un solo carattere e

00:03:21che stanno per essere circondato da

00:03:23apici Quindi diciamo che ho un

00:03:26categoria uguale e una scrittura del genere e

00:03:29ci si va e un carattere molto

00:03:31in particolare sta andando a prendere una

00:03:33byte all’interno della memoria boolean S– che

00:03:36normalmente iniziare con è ogni volta che siete

00:03:39definire il nome della variabile può contenere

00:03:41vero che sta per essere numerabile a 1

00:03:43o false che sta per essere comparabili

00:03:46a 0 in Saur interi sono solo tutto

00:03:49numeri senza decimali carri

00:03:52numeri in virgola mobile sono come

00:03:53doppie e normalmente sono accurate

00:03:56fino a 6 cifre decimali diciamo solo

00:03:58numero preferito e basta copiare questo ragazzo

00:04:01e raddoppia, naturalmente, come ho detto prima

00:04:03sono anche numeri a virgola mobile ma hanno

00:04:05tendono ad essere precisi fino a circa il 15

00:04:07cifre di lunghezza e poi, naturalmente, se io

00:04:09vogliono uscita una di queste variabili su

00:04:12lo schermo ho intenzione di utilizzare C di nuovo

00:04:13e poi potrei dire numero preferito

00:04:16all’interno di virgolette doppie e poi a

00:04:19esso uscita

00:04:19Ho appena messo un altro staffa all’interno della

00:04:21ci faccia

00:04:21nom e poi naturalmente e L per un

00:04:24carattere turno in lì si può vedere

00:04:25favorito numero 3.14159 Ora, naturalmente,

00:04:28ci sono altri tipi di dati che sono

00:04:30available lati corti che sono

00:04:32sta per essere almeno 16 bit in formato

00:04:33long int, che stanno per essere almeno

00:04:3532 bit di lunghezza lungo int che stanno per

00:04:38essere almeno 64 int unsigned che sono

00:04:40sta per essere la stessa dimensione come il sottoscritto

00:04:41Versione e lunghe doppie che non sono

00:04:43meno in termini di dimensioni rispetto ai normali vecchi raddoppia se

00:04:46si vuole scoprire il numero di byte

00:04:49per un tipo di dati che potremmo venire qui

00:04:51e andare a C fuori e dire qualcosa di simile

00:04:53dimensione del int potremmo poi richiamare dimensioni

00:04:57di e mettere la mia età all’interno di lì dal

00:05:00è un int e dentro C ++ tutti

00:05:03dichiarazioni terminano con un punto e virgola in modo che

00:05:04potrebbe saltare solo qui a mantenere

00:05:06tutto sullo schermo e andare come

00:05:07che compilare ed eseguire si può vedere

00:05:09qui dimensione di un int è 4 byte se

00:05:12Vorrei poi andare a fare esattamente la stessa

00:05:14cose per carri personaggi di bullismo

00:05:16e raddoppia ed eseguire si può vedere come

00:05:18molti byte sono in ciascuno di quelli come

00:05:19bene se vi state chiedendo quanto è grande un

00:05:21numero può essere basata off di byte e così

00:05:23via e così via andiamo qui e

00:05:25cerchiamo di creare il più grande che possiamo int

00:05:27possibilmente creare e ogni volta che conosciamo la

00:05:30Infatti quanti byte un INT può contenere

00:05:32possiamo quindi andare in e definire esattamente come

00:05:35grande che il numero sarebbe stato e si può

00:05:36vedere proprio qui questo è il più grande

00:05:38intero potevamo forse avere e se

00:05:40è andato qui e detto hey andiamo a

00:05:42con che in questo modo e si può vedere

00:05:44esso stampa esattamente il modo in cui si

00:05:46ci si aspetta che se andiamo un

00:05:48più e mettere un 8 in là e detto risparmiare

00:05:51che e ricompilare si sta andando a vedere

00:05:53che si ottiene completamente diverso

00:05:54risultati vedono ritorna come un fatto negativo

00:05:55numero che è solo la dimostrazione di

00:05:57ciò che accade ogni volta che si va fuori di

00:05:59i limiti che utilizzano i dati diversi

00:06:02tipi quando si tratta di aritmetica sei

00:06:04andando ad essere in grado di utilizzare più e meno

00:06:06e moltiplicazione e divisione pure

00:06:08come modulo che sta per restituire la

00:06:11resto di una divisione stiamo anche andando

00:06:13per poter utilizzare scorciatoia incrementale

00:06:15notazione così come decrementale ti danno

00:06:17un esempio di quello che sembra

00:06:19è possibile vedere proprio lì sullo schermo

00:06:20ed esattamente come si desidera eseguire

00:06:22Inoltre se si voleva in uscita che in

00:06:24lo schermo come questo e per dimostrare

00:06:25i collegamenti per incrementi e

00:06:28decrementi Diciamo che abbiamo un int

00:06:31e sto solo andando a dare chiamarlo 5 e

00:06:32dare il valore di output sul 5 poi

00:06:34il nostro schermo 5 plus plus è uguale e

00:06:37poi prendere la variabile 5 5 e incremento

00:06:40che io poi incrementarlo da sinistra

00:06:42lato e poi ti decrementare dal

00:06:43lato destro e poi mi farlo diminuire

00:06:46dal lato sinistro e si vede che cosa è

00:06:47succedendo proprio qui, in questa situazione

00:06:49ogni volta che si incrementa da destra

00:06:51lato si sta per effettuare effettivamente

00:06:53che l’azione dopo ottiene la corrente

00:06:55valore di 5, che è il motivo per cui si vede

00:06:575 Ecco allora qui ogni volta che si

00:06:59incrementare sul lato sinistro è

00:07:02andando a incrementarlo un primo momento è

00:07:04ricordo che attualmente ha un valore di 6

00:07:05perché questo è quello che è successo qui e

00:07:07questo è il motivo per cui si ottiene un 7 su

00:07:09qui e allo stesso modo ogni volta che avete

00:07:11decremento sul lato destro si verifica

00:07:13dopo che il valore è preso qui e poi

00:07:16Qui si vede che entrambi sono

00:07:17diminuisce o siamo tornati alle 5 di nuovo

00:07:19saremmo anche in grado di venire qui e

00:07:20utilizzare un’altra forma di assegnazione abbreviata

00:07:23notazione andando 5 più o uguale a e

00:07:27diciamo 5 in questa situazione che a destra

00:07:29ci sta per essere equivalente a se

00:07:31avevi 5 è uguale a 5 più 5 a destra

00:07:35così o cambiamo questo in 6 così

00:07:37non è abbastanza così confuso e sì

00:07:39potrebbe mettere più istruzioni qui

00:07:41la stessa linea solo finché si dispone di

00:07:42virgola Ecco come C ++ definisce che una

00:07:45dichiarazione è finita un’altra cosa che è

00:07:47importante è capire ordine di

00:07:49operazione che sostanzialmente si afferma che

00:07:51se avete un po ‘di calcolo che è

00:07:53essendo eseguita la moltiplicazione e

00:07:55divisione stanno per essere eseguiti

00:07:57prima di qualsiasi aggiunta o sottrazione e

00:07:59è possibile vedere proprio qui esattamente ciò che

00:08:01stiamo facendo qui ho parentesi graffe intorno

00:08:03le aggiunte e sottrazioni e fino

00:08:05Qui non e qui se eseguo

00:08:07può vedere Ottengo drammaticamente diverso

00:08:08risultati perché è che bene in questo

00:08:11situazione che stanno per avere la

00:08:13moltiplicazione verificarsi prima che è dove

00:08:15si sta andando ad ottenere 6 proprio qui allora

00:08:16stiamo andando a saltare dentro ed avere questo componente aggiuntivo

00:08:19fino a 3 che viene a negativo 3

00:08:21questa situazione che andremo a svolgere

00:08:22addizione e sottrazione primo che è

00:08:24andando a dare un valore pari a 0 in modo che quando

00:08:26questo è moltiplicato volte 2 si sta andando

00:08:28per ottenere 0 in modo utilizzare le parentesi per tutto il tempo è

00:08:30andando a risparmiare un sacco di problemi ora

00:08:32diciamo che veniamo qui

00:08:34e vogliamo mostrare qualche divisione qui

00:08:36sul nostro schermo e questo è esattamente il modo in cui

00:08:38fanno che 4/5 bene se eseguiamo che

00:08:42potrebbe non ottenere il risultato che cercavamo

00:08:44per il quale in questa situazione esce

00:08:46a zero quello che accade ogni volta che vogliamo

00:08:48in realtà mostrano un numero floating-point

00:08:49qui con i decimali al posto di

00:08:51fondamentalmente solo uscendo a zero è

00:08:53in realtà molto semplice, basta venire qui

00:08:55e abbiamo intenzione di eseguire ciò che è

00:08:56chiamato casting per lanciare da una qualsiasi delle

00:08:58diversi tipi di dati che si vuole

00:09:00prendere il tipo che si desidera cast

00:09:01metterlo tra queste parentesi e si

00:09:04Potete vedere qui ora compilare ed eseguire

00:09:05si sta andando ad ottenere esattamente quello che

00:09:07volevano e, naturalmente, questi possono essere

00:09:08eseguita mettendo in int lato qui

00:09:11di gettare in un numero intero, anche se questo è

00:09:12esattamente quello che è

00:09:13personaggi, nonché doppie destra come

00:09:16che ora si può sbarazzarsi di tutto questo

00:09:18roba qui in modo che possiamo concentrarsi su se il

00:09:20formula, ormai se le dichiarazioni solo

00:09:22fondamentalmente andare ad eseguire diversi

00:09:23codice a seconda delle diverse condizioni

00:09:25si sta andando ad avere confronto

00:09:26operatori che stanno per essere uguale a

00:09:28non uguale a superiore inferiore

00:09:31maggiore o uguale o inferiore a un

00:09:34pari a si sta anche andando ad avere

00:09:35operatori logici che stanno per essere

00:09:37eo o no e che stanno andando a venire

00:09:40sotto forma di eo o no andiamo

00:09:43e dare un’occhiata ad alcuni esempi di come

00:09:44potremmo usare questi diciamo che abbiamo

00:09:46creare un’epoca che è pari a 70 anni

00:09:49vecchio e un’altra età in ultimo esame di lasciare

00:09:54diciamo che vogliamo impostare un piccolo programma

00:09:55qui che sta andando a definire se un

00:09:57persona sta per essere in grado di guidare o

00:10:00Non e poi abbiamo non è intossicato

00:10:04e abbiamo intenzione di impostare che a true

00:10:05sempre una buona cosa, se avete intenzione di

00:10:07guidiamo ora stiamo andando a venire qui

00:10:09con le nostre affermazioni, se stiamo andando a

00:10:10dire qualcosa come se l’età è maggiore

00:10:12o uguale a uno e c’è il

00:10:16operatore logico assicurarsi di chiudere tutti

00:10:18le staffe fuori dell’età modo giusto è

00:10:20meno di 16 in questa situazione Oh in

00:10:23questa situazione stiamo andando a dire che

00:10:25essi non possono guidare la società, se vogliamo

00:10:27verificare un’altra condizione stiamo solo andando

00:10:29digitare il resto, se in questa situazione

00:10:31diamo un’occhiata per vedere se sono

00:10:32intossicato in questa situazione siamo

00:10:34intenzione di utilizzare il simbolo, non e siamo

00:10:36andare a dire che non è intossicato e tutti

00:10:39che sta andando a fare è prendere questa vera

00:10:41proprio qui il non in questa situazione e

00:10:43trasformarlo in falso e in quella situazione

00:10:46dove dice che non si può provare

00:10:47ancora una volta ho potuto anche venire qui e fare

00:10:49una cosa ancora più complicata se e

00:10:52potrebbe dire qualcosa di simile età è maggiore

00:10:54o uguale a 80 e poi fare un altro

00:10:58completamente età confronto diverso è

00:11:01superiore a 100 o più staffe qui

00:11:04età – età in ultimo esame e quindi chiudere

00:11:10quello via maggiore di cinque e poi

00:11:12chiudere questi off Quindi quello che sto praticamente

00:11:13dicendo qui è se la persona è sopra la

00:11:17All’età di 100 non stiamo andando per consentire loro

00:11:19a guidare se hanno intenzione di essere più

00:11:22l’età di 80 o uguale a siamo

00:11:25fondamentalmente andando a imporre loro di adottare

00:11:27un esame ogni cinque anni per verificare che

00:11:30in realtà sono ancora in grado di guidare

00:11:32è una specie di un esempio di contorto, ma

00:11:34Sto solo cercando di trovare un motivo per essere

00:11:35in grado di venire qui e come mostrano

00:11:37tutte queste cose differenti funzionano e in

00:11:39questa situazione stiamo andando a dire che

00:11:40essi non possono guidare e poi finalmente in cui

00:11:43tutto il resto che non è controllato se ci

00:11:45desidera loro di avere la capacità di guidare

00:11:46se lo fanno il corridoio qui

00:11:48stiamo andando a digitare solo in altro e

00:11:49ci si va si sta andando a vedere che

00:11:51che funziona per voi e qui se ci

00:11:52eseguirlo si sta andando a vedere che sì

00:11:54infatti questa persona può guidare in modo che un

00:11:56Esempio abbastanza contorto di come utilizzare

00:11:58se le dichiarazioni così come gli altri e gli altri

00:12:01se ora diamo uno sguardo a interruttore

00:12:02dichiarazione che è fondamentalmente sta per essere

00:12:04utilizzato ogni volta che si dispone di un numero limitato

00:12:05di possibili opzioni Quindi diciamo che abbiamo

00:12:08int opzione saluto e diciamo che

00:12:11scelto due poi quello che stiamo andando a essere

00:12:13in grado di fare è controllare le versioni o la

00:12:16I valori di opzione di saluto con la nostra

00:12:18istruzione switch ha messo dentro di ricci

00:12:20staffe di nuovo che andremo a dirlo caso

00:12:22se il valore dell’opzione saluto è uguale

00:12:25a 1 bene, allora stiamo andando a dire che

00:12:28vogliamo stampare sullo schermo

00:12:29Bonjour poi saltare fuori dello switch

00:12:32dichiarazione tutti insieme stiamo andando a

00:12:33digita pausa e, se non è stata selezionata

00:12:35che sta andando a continuare a controllare tutti

00:12:37gli altri valori possibili piace

00:12:40salterà giù qui se non si dispone di

00:12:41rompere dentro e controllare per vedere se ha

00:12:43il valore di 2 così si vuole fare in modo

00:12:44le pause in là

00:12:45potrebbero avere hola e tutte queste altre

00:12:48diverse opzioni e poi infine con

00:12:50l’istruzione switch, se si vuole avere

00:12:52una cosa di default che sta andando a fare se

00:12:54nessuna delle altre cose che corrispondono solo

00:12:55digitare in default e poi vedere fuori e

00:12:58ciao a destra come quello

00:12:59necessario rompere qui in questa situazione e

00:13:01si può vedere in base al largo il fatto che essi

00:13:03è entrato a sentire che le stampe Jolla

00:13:05Sullo schermo che è fondamentalmente

00:13:07tutto ciò che serve sapere sul

00:13:08istruzione switch farò dare un’occhiata a

00:13:09l’operatore ternario che sta per

00:13:11eseguire un’assegnazione basato fuori di un

00:13:13condizione e dei suoi formati di base che vanno a

00:13:15essere variabile è uguale a ci sara ‘

00:13:18essere una condizione qui seguita da una

00:13:20punto interrogativo e questo è il valore che è

00:13:22sta per essere assegnato se è vero e

00:13:24questo sta per essere il valore che è

00:13:26assegnato se è falso e visualizzare la

00:13:28vero esempio diciamo che abbiamo integer

00:13:31grande num e in questa situazione sono

00:13:33intenzione di utilizzare i numeri reali che andremo a

00:13:35abbiamo la nostra condizione è maggiore di 5 a

00:13:37mettere il nostro punto di domanda se è vero allora

00:13:39stiamo andando per assegnare il valore di 5 a

00:13:41maggior numero e se è falsa siamo

00:13:43andando per assegnare il valore 2 che

00:13:45il numero e poi, naturalmente, potremmo stampare

00:13:46che fuori sullo schermo è così semplice

00:13:48operatore ternario e ora diamo uno

00:13:50guarda array ora raggi sono solo andando

00:13:52memorizzare più valori dello stesso

00:13:54tipo di dati quindi cerchiamo di venire qui e

00:13:56fornire il nostro tipo di dati per la nostra gamma solo

00:13:59pensare a un rilancio come scatole perché

00:14:01che è fondamentalmente quello che sono nella memoria

00:14:02Quindi cerchiamo di avere una matrice qui e avere

00:14:04definire all’interno di matrici quante

00:14:06scatole avete bisogno o come molti pezzi di

00:14:09dati che si desidera memorizzare nella loro al

00:14:10fin dall’inizio e quindi questo non può essere

00:14:12cambiato vedremo successivamente vettori

00:14:14ogni volta che vogliamo guardare un modo per

00:14:15modificare tali valori potrebbero anche venire in

00:14:17qui e diciamo che vogliamo un allineamento completo

00:14:20di numeri male ed è anche andando a

00:14:22bisogno di 5 spazi per contenere questi numeri questo

00:14:25situazione che potremmo venire qui e tipo

00:14:27in tutti questi numeri che vogliamo memorizzare

00:14:30proprio come quello che si sta andando ad essere in grado

00:14:31per ottenere il primo elemento dell’array con

00:14:33un’etichetta e le etichette per tutti questi

00:14:36elementi di matrice stanno per iniziare con 0 in modo

00:14:38questo sta per avere un indice o un’etichetta

00:14:40di 0 è 1 2 3 4 e se vogliamo che il

00:14:44primo numero male in questo array

00:14:46stiamo andando a digitare 0, proprio come ho

00:14:48detto e cambiare questo alle cattive nums compilare

00:14:51ed eseguire si sta andando a vedere i quattro

00:14:52si apre perché ha l’indice di 0

00:14:54stiamo anche andando ad essere in grado di venire in

00:14:56qui e creare array multidimensionali

00:14:58che è solo andare a essere scatole di scatole

00:15:01quindi diciamo che ho voluto avere un

00:15:02array di caratteri che sta per essere

00:15:04multidimensionale e ho intenzione di avere

00:15:065 spazi nel primo array che è

00:15:09creato qui

00:15:10e cinque nella seconda lettura che è

00:15:12creato qui ho potuto quindi entrare e

00:15:14definisco che voglio conservare le lettere

00:15:16per il mio nome che andremo a utilizzare due ricci

00:15:18staffe in questa situazione allora siamo

00:15:20andando a chiudere fuori che prima con un

00:15:22parentesi graffa di chiusura e poi aprirlo

00:15:24di nuovo e qui posso mettere il mio cognome abbiamo

00:15:26saltare giù alla riga successiva, quindi è un

00:15:27po ‘più facile da vedere e che stiamo usando

00:15:29caratteri qui personaggi usano sempre

00:15:30virgolette singole stringhe come si sta andando ad

00:15:32vedrà più avanti sempre usare le virgolette

00:15:34e poi finalmente dopo che abbiamo tutti coloro

00:15:36nel mettere due graffe in là chiusura

00:15:38e ci si va che è un

00:15:39array multi-dimensionale, se si farebbe

00:15:41poi si desidera entrare in possesso di e stampare

00:15:44l’diciamo che la seconda lettera nella

00:15:46secondo array si vede di nuovo secondo

00:15:49lettera nella seconda matrice andremmo mia

00:15:52nome in questa situazione e vogliamo

00:15:54ottenere il secondo bene in quella

00:15:56situazione secondo è uguale a uno e

00:15:58poi la seconda lettera nella seconda

00:16:01array di andare a destra così e non ci si

00:16:02può vedere proprio lì un salta fuori che è

00:16:05esattamente quello giusto

00:16:06si potrebbe anche entrare e cambiare la

00:16:07valore nella matrice semplicemente utilizzando il suo

00:16:09indice

00:16:10così diremo il mio nome e diciamo che

00:16:12vuole ottenere il primo array che è

00:16:14zero in questa situazione e la seconda

00:16:16lettera all’interno di esso o la terza lettera

00:16:18in esso in questa situazione e noi vogliamo

00:16:20cambiare la situazione a e nessun problema allora venire in

00:16:22qui e cambiare questo esattamente lo stesso

00:16:24posizionare POW ed eseguire e si può vedere

00:16:26qui il nuovo valore è posta proprio come abbiamo impostato

00:16:29proprio lì ora ho intenzione di lasciare

00:16:30tutto qui, perché ho intenzione di usare

00:16:32mentre io dimostrare esattamente come il

00:16:33per il ciclo ora funziona il ciclo for solo

00:16:35consente di continuare l’esecuzione di codice come

00:16:37fino a quando la condizione è vera e si è

00:16:39andando a definire con la qui Io sono

00:16:41andando a dare il tipo di dati per il valore

00:16:43che ho intenzione di incrementare e dare

00:16:44che il valore iniziale di un ho intenzione di

00:16:46diciamo che stiamo andando a continuare

00:16:47incrementando il tempo che mi è meno

00:16:49o uguale a dieci e poi dovremo

00:16:51incrementarlo proprio qui parentesi graffe

00:16:53e all’interno del ciclo for potremmo andare

00:16:55vedere fuori e basta stampare tutti questi su

00:16:58nostro schermo e non ci si può vedere

00:16:59stamparlo da uno a dieci

00:17:00Ora potremmo anche venire qui e uso

00:17:02nostra matrice multidimensionale impilando

00:17:05interno per i cicli e dobbiamo solo andare per

00:17:08ed intero J è uguale a zero siamo

00:17:12intenzione di usare lo zero qui perché gli array

00:17:14iniziare con l’indice zero così siamo

00:17:15andare a dire wow J è inferiore a cinque

00:17:17abbiamo intenzione di continuare a scorrere

00:17:19qui e poi all’interno di qui stiamo andando

00:17:21a

00:17:21un’altra per il ciclo diamo questo BK è

00:17:23pari a zero bene è inferiore a cinque

00:17:25incrementare il valore di K ora possiamo venire

00:17:28qui e stampare tutta la mia intera

00:17:30nome da solo mettendo a posto J interno

00:17:32lì e poi finalmente vedere non ho messo

00:17:34Alla fine L in là dopo che è fatto di andare

00:17:36attraverso il ciclo for ho potuto poi venire

00:17:38qui e mettere il ritorno del carrello in

00:17:39ed eseguire e non ci si può vedere

00:17:41stampato il mio nome ricorda ho cambiato

00:17:43l’e qui e poi è andato e stampata

00:17:45il cognome ed è quello che è

00:17:46semplicemente andando a fare è andare a andare

00:17:48il primo ciclo matrice attraverso tutto

00:17:50utilizzo di questo ciclo for proprio qui facciamo

00:17:52vieni qui e poi J sta per

00:17:54vieni qui e sta andando a stampare

00:17:55tutto ciò in modo che sia come per i loop

00:17:57lavorare ora diamo uno sguardo quando si è

00:17:59loop ora si sta andando a usare mentre

00:18:00loop invece di cicli for quando si

00:18:02non sapere in anticipo quando il ciclo

00:18:04sta per finire Quindi diciamo che abbiamo un

00:18:06di numeri casuali e questo è come si farebbe

00:18:08generare numeri casuali all’interno di C ++ che

00:18:11andare Rand e diciamo che volevo

00:18:13ottenere numeri casuali tra 1 e 100

00:18:16Modulo 100 come come che ora questo ragazzo

00:18:20solo sta andando a generare casuale

00:18:21numeri compresi tra 0 e 99 Quindi, se voglio 1

00:18:25a 100 ho intenzione di mettere un 1 proprio qui

00:18:26ora con un ciclo while posso dire che ho

00:18:29vogliono continuare a pedalare attraverso questo

00:18:31ciclo fintanto che il numero casuale non è

00:18:34pari a 100 e abbiamo potuto stampare su

00:18:37lo schermo il numero casuale ogni

00:18:39tempo singolo e in questa situazione di lasciare

00:18:41diciamo che vogliamo mettere una virgola tra lì

00:18:42chiudere quella fuori ma ovviamente sei

00:18:44andando a bisogno di un modo per uscire da questo

00:18:47ciclo while in modo che il numero casuale sta andando

00:18:49di dover cambiare in modo da andare e generare

00:18:50un altro numero a caso assicurarsi che usiamo

00:18:52la stessa cosa di nuovo e poi dopo abbiamo

00:18:54sono fatte con il nostro ciclo while mettere un

00:18:56ritorno a capo in là, ma non

00:18:57dimenticate di mettere il segno di uguale in là

00:18:59ora andiamo a vedere quanto tempo ci vuole

00:19:00noi per arrivare a 100 ci si può vedere

00:19:03stampati tutti quelli fuori proprio lì sul nostro

00:19:04schermo e non lo so io non ho intenzione di

00:19:06contare quanti di questi sono lasciate poi

00:19:07prendere tanto tempo per venire con un casuale

00:19:09numero di 100 un’altra cosa che è gentile

00:19:11di interessante è che si può fondamentalmente

00:19:12simulare esattamente quello che un ciclo for fa

00:19:14utilizzando un ciclo mentre l’unica cosa che è

00:19:17stiamo andando ad avere per avere qualcosa

00:19:19che sta andando a incrementare per noi questo

00:19:20Indice proprio qui andrà bene e in

00:19:22questa situazione ovviamente tenerlo fuori

00:19:24del ciclo while proprio come abbiamo fatto con

00:19:26il nostro numero casuale prima che andremo a

00:19:27diciamo che vogliamo scorrere riga come

00:19:29Finché indice è minore o uguale a

00:19:32dieci poi all’interno del valore di uscita di

00:19:34indice e poi, naturalmente, incrementare la vostra

00:19:38indice destro qui e si può cantare fare

00:19:40più o meno esattamente la stessa cosa che si

00:19:41può fare con un ciclo for con ciclo while

00:19:43e che ci porta a fare cicli while e

00:19:44che stanno andando a essere utilizzato ogni volta che si

00:19:46desidera eseguire tutto ciò che è in loop

00:19:48per lo meno una volta e sono anche

00:19:51andando a parlare di stringhe qui per un

00:19:52secondo perché ora stiamo andando anche

00:19:54Coprire come ottenere l’input dell’utente creiamo un

00:19:56stringa che è solo una serie di

00:19:58personaggi

00:19:59questo è tutto stringa è il numero int int

00:20:02ospiti danno questo valore di 0 inizio off

00:20:05e poi la do-while solo andando

00:20:06per cominciare con fare e poi nel

00:20:08molto fine di esso abbiamo intenzione di avere un

00:20:10mentre una parte in modo da sapere è tutto

00:20:12sta per essere giustiziato, che è nel ciclo

00:20:14almeno una volta, anche se il numero degli ospiti

00:20:16non è pari a 4 in modo che il numero degli ospiti

00:20:19non è uguale a 4 e questo sta per

00:20:22essere una base come il gioco indovinare e si

00:20:23mettere un punto e virgola qui alla fine

00:20:25non dimenticare che oggi all’interno di questa

00:20:27stiamo andando a prendere un po ‘input dell’utente siamo

00:20:29andando a cominciare dicendo che il

00:20:31utente del nostro programma è quello di indovinare un numero

00:20:35tra 1 e 10 che vogliamo permettere che il nostro

00:20:38all’utente di inserire alcuni input e per farlo

00:20:41stiamo andando a digitare in linea get siamo

00:20:43andando a digitare cin che sta per

00:20:45essere la fonte del input dell’utente che è

00:20:47sta per essere la tastiera in questo

00:20:49situazione e poi stiamo andando ad avere

00:20:50per dire dove vogliamo che il valore di essere

00:20:52memorizzati in questa situazione vogliamo

00:20:53memorizzarlo nella guest numero di stringa se

00:20:56vogliamo convertire la stringa in un

00:20:58intero possiamo quindi andare int camere Numero

00:21:00abbiamo bisogno di fare questo, perché questo ragazzo

00:21:03qui non stiamo andando ad essere in grado di

00:21:04confrontare una stringa in un numero intero di 4 è

00:21:07abbastanza facile da cambiare stiamo solo andando

00:21:09digitare s TOI

00:21:10che sta per convertire una stringa in

00:21:11un intero e poi passeremo a numero

00:21:14gli ospiti, che è la nostra corda e poi siamo

00:21:16potrebbe stampare int ospite numero se ci sarebbe

00:21:18come e questo è destinata a continuare a

00:21:20ciclo fino a quando non inserire il numero di

00:21:21quattro e poi se ottengono fuori del nostro

00:21:23do-while potevamo entrare e andare

00:21:25vedere fuori si vince altrimenti sta andando

00:21:27continuare a chiedere loro come si vedrà indovinare

00:21:29tra 1 e 10 io digito in 1 mi chiedono

00:21:32ancora

00:21:322 ora è possibile vedere voglio giusto così

00:21:35c’è input dell’utente conversione da

00:21:37stringhe in numeri interi do-while e un

00:21:39sacco di altre cose diverse

00:21:40diamo uno sguardo più profondo a paglia

00:21:43ora in C ++ rispetto al C ++ C è

00:21:46andando a fornire noi con oggetti stringa

00:21:48e tu sei come ho detto prima che siano

00:21:50andando sempre essere circondato con

00:21:52virgolette doppie e solo per coprire questo

00:21:54vero brevemente all’interno di C si avrebbe

00:21:56già fatto stringhe dicendo

00:21:58qualcosa come copia serie di sei come questo

00:22:00è uguale a e quindi creato un carattere

00:22:03allineamento quindi mi limiterò a scriv felice e

00:22:05poi si doveva finire sempre con un

00:22:07barra rovesciata e poi uno zero con chiusura

00:22:09parentesi graffa ed è così che siamo stati

00:22:11utilizzando stringhe all’interno di C il modo in C ++ è

00:22:14molto meglio e più facile così che andremo a

00:22:17dire stringi stringi compleanno è pari a

00:22:20spazio nella loro compleanno e ci siamo

00:22:22abbiamo finito ora potremmo naturalmente

00:22:23combinare questi ragazzi e di come stiamo andando

00:22:26combinarli è con il

00:22:28operatore di concatenazione o solo il più

00:22:30firmare o si può semplicemente chiamare combinato

00:22:32si può chiamare quello che vuoi

00:22:33così stringa di compleanno e lì si può vedere

00:22:35è stampato buon compleanno combinare entrambi

00:22:37di chi li stampare lo schermo

00:22:38ed eseguire un paio di altri diversa

00:22:40operazioni diciamo chiamiamolo questo

00:22:42il tuo nome sempre bisogno di definire la vostra

00:22:44variabili prima di usarli e poi

00:22:46Ho intenzione di farlo entrare e di stampa

00:22:48fuori lo schermo per ottenere qualche utente

00:22:50Ingresso qual è la vostra linea di nome get è

00:22:53andando ad ottenere l’input dell’utente ottenere da

00:22:55il negozio della tastiera quello che entrano

00:22:57nel tuo nome e quindi ho potuto andare a vedere

00:22:59fuori ciao mettere il vostro nome all’interno di lì

00:23:01qual è il tuo tipo di nome in Derrick ciao

00:23:03Derrick mi parla potuto quindi entrare in

00:23:05e creare diciamo doppia in questo

00:23:08situazione c’è costante non si fa

00:23:10sa di cosa si tratta non ti preoccupare che sia

00:23:12solo un numero casuale di pensiero o

00:23:14Euler pensato in realtà ho potuto poi

00:23:15andare stringa di Eulero indovinare che vogliamo fare come

00:23:18un’applicazione maiuscolo piccolo quiz

00:23:21lettera proprio lì rende solo più facile

00:23:23per essere in grado di leggere i nomi delle variabili

00:23:25e poi andrò Eulero indovinare doppio e

00:23:27ora venire qui chiedere loro che cosa è chi

00:23:31costanti ho potuto quindi ottenere quello che

00:23:34entrare all’interno di qui non ti preoccupare

00:23:36è ho intenzione di mostrare come convertire

00:23:37da doppie e o da stringhe

00:23:39doppie abbiamo bisogno di fare per convertire da un

00:23:42stringa in un doppio e stiamo andando a

00:23:43conservarlo in Euler indovinare doppia è di tipo

00:23:47in invece sto I STO D

00:23:50giusto così e imparerete indovinare

00:23:52è il valore della stringa sono entrati e

00:23:54allora ti dirò se più vecchio indovinare doppio

00:23:57è pari a Euler costante che si può

00:24:00vedi tutti coloro sullo schermo ricci

00:24:02staffe di nuovo vedere fuori hai ragione e

00:24:04poi il resto si è sbagliato fino assicuratevi

00:24:07venire qui e lo mise s interno

00:24:09ci costante costante di Eulero di Eulero

00:24:11eseguire come ti chiami Derek che cosa è

00:24:13Costante di Eulero 0,577 21 hai ragione

00:24:16si può vedere esattamente come funziona

00:24:18paio di altre cose che possiamo fare con

00:24:20STRINGS si vuole ottenere questa dimensione o il

00:24:23il numero di caratteri di una stringa di vedere fuori

00:24:25dimensione della stringa che si potrebbe usare Euler indovinare

00:24:27in questa situazione e poi basta chiamare

00:24:29dimensioni quindi è praticamente esattamente quello che

00:24:31pensato che sarebbe stato quando per verificare se un

00:24:33stringa è vuota Eulero indovinare ancora e

00:24:35basta digitare grande vuoto per usare ogniqualvolta

00:24:38si vuole testare l’input da un utente potrebbe

00:24:40utilizzare append anche per essere in grado di aggiungere

00:24:43stringhe

00:24:44quindi abbiamo potuto ottenere Eulero indovinare e chiamata

00:24:46aggiungere e poi aggiungere qualcosa di simile era

00:24:49i vostri ospiti rimbalzato là fuori di lì

00:24:51tu vai

00:24:52Tipo di Turk virgola cinque li ha lasciati che in te

00:24:54sbagliavamo non importa dimensione della stringa

00:24:56è pari a tre vedere proprio lì

00:24:58decimale cinque cinque che è il tre è

00:25:00stringa vuota 0 torna o false

00:25:02ovviamente non è vuota e la stampa

00:25:04i miei ospiti là sullo schermo vengono

00:25:07qui e creare un’altra stringa facciamo

00:25:08chiamare questa stringa cane dare il valore

00:25:10di cane e gatto stringa di dargli il valore

00:25:13di gatto possiamo confrontare i numeri quindi cerchiamo di

00:25:16diciamo quando vediamo fuori o confrontare le stringhe

00:25:18li con funzione di confronto e

00:25:20cambiamo questo per cane e questo la

00:25:22gatto e cambiare questo il cane e si può

00:25:25vedere in questa situazione ogni volta che un valore

00:25:27è uguale come è qui stringa di cane e

00:25:30stringa di cane si sta andando ad ottenere un ritorno

00:25:31valore 0 si sta andando a ricevere un 1

00:25:34in questa situazione, se è meno di e

00:25:36uno negativo se è maggiore di e

00:25:39tutto questo è basato fuori alfabetico così

00:25:41potremmo anche venire qui e segno

00:25:43copie di un valore ad un altro ci stringa

00:25:46andare intero nome è uguale a e Vai

00:25:49nominare un segno e potrei dire il tuo nome

00:25:51e ci si va

00:25:52Ho potuto quindi ottenere una stringa quindi cerchiamo di

00:25:55dire che ho voluto ottenere il primo nome

00:25:56tempo fa

00:25:58come quel puntino un figlio e vorrei passare

00:26:01la stringa voglio lavorare con l’allora

00:26:03partendo indice da cui voglio

00:26:05prima iniziare a tirare i personaggi e poi

00:26:07il numero di caratteri che voglio, che è

00:26:08cinque Potrei poi venire qui cambiamento

00:26:10questo solo per citarne prima se ho digitato il mio pieno

00:26:12nome allora si sta andando a dire che

00:26:13appena afferrato la sottostringa fino Derrick I

00:26:16potrebbe poi eseguire una ricerca su una stringa

00:26:17quindi diciamo che volevo trovare il

00:26:19Indice del mio cognome ottenere il cognome

00:26:22indice se non sapessimo che ho potuto digitare

00:26:25nel tuo nome e poi trovare seguito da

00:26:27la stringa che voglio trovare all’interno

00:26:30di lì e l’indice che voglio

00:26:31avviare la ricerca da e quindi ho potuto

00:26:33dire indice per cognome indice cognome

00:26:37è la mia piena di dati nome punto e si può vedere

00:26:40l’indice inizia alle sei e se si conta

00:26:42sopra si sta andando a vedere che in realtà B

00:26:44è sei e anche inserire sta per consentire

00:26:48me di mettere in una stringa in corrispondenza dell’indice

00:26:51Gli dico di metterlo in modo da andrò inserto

00:26:53cinque così a partire dal indice cinque voglio

00:26:56messo nella parola Justin cambiare questo a

00:26:58il tuo nome solo così si può vedere che qui

00:27:00in un secondo potrei anche cancellare o eliminare

00:27:02sei caratteri a partire dall’indice di

00:27:04sette e vorrei solo andare a tuo nome

00:27:07ancora una volta la stringa voglia di lavorare con un

00:27:08gara a partire dalle sei

00:27:10Voglio cancellare sei caratteri di partenza

00:27:13al settimo indice e quindi stamparlo

00:27:15là fuori di nuovo e poi finalmente ho potuto

00:27:18anche entrare e sostituire diciamo che mi

00:27:20voler sostituire cinque caratteri di partenza

00:27:22all’indice sei ben c’è l’indice 6 in modo

00:27:25Voglio sostituire cinque caratteri e

00:27:26diciamo che voglio cambiarlo

00:27:28Massimo

00:27:29così il mio nuovo nome sarà Massimo e rendere

00:27:31Assicurarsi che si chiama il vostro nome ed ecco

00:27:34il mio nome è possibile vedere tutte le modifiche che

00:27:36sono fatti per proprio lì ho inserito

00:27:37solo e dentro di lì proprio lì ho

00:27:40sbarazzato di esso e poi proprio qui ho

00:27:41Eseguita una sostituzione di cambiare il mio ultimo

00:27:43nome di Maximus quindi c’è un sacco di

00:27:46roba sulle stringhe di bene ora parliamone

00:27:48su vettori ora vettori sono proprio come

00:27:50un alzare l’unica vera differenza è che

00:27:52le loro dimensioni possono cambiare e come si crea

00:27:54un vettore è di tipo in vettoriale e quindi la

00:27:57DATATYPE si desidera memorizzare poi poi

00:27:59diciamo che ho intenzione di conservare o

00:28:01numeri della lotteria nel mio vettore ho intenzione

00:28:03per decidere che la dimensione iniziale dovrebbe

00:28:05presto 10 ho potuto quindi creare un array

00:28:09vi mostrerà come

00:28:10mettere un array in un vettore e diciamo

00:28:12essa ha una dimensione di cinque e poi ci

00:28:15inizializzare proprio come abbiamo fatto prima del 14

00:28:1824 e 34 del genere possiamo poi andare a

00:28:22prendere il nostro vettore e inserire nostra matrice e

00:28:27come stiamo andando per farlo è andare lotteria

00:28:29numero

00:28:30EFFETTO E diciamo che vogliamo iniziare

00:28:32inserendo all’inizio del nostro vettore

00:28:34e allora diremo l’array che abbiamo

00:28:37vuole inserire in esso e poi lasciare di

00:28:39diciamo che vogliamo solo prendere la prima

00:28:42tre numeri del nostro campo di destra come

00:28:45che potremmo poi andare a vedere fuori e basta

00:28:48numero di stampa della lotteria del genere e al

00:28:52e diciamo che vogliamo ciò che è il terzo

00:28:55elemento che sarebbe seconde urla indice

00:28:57come questo

00:28:58Uscimmo mettiamo che sullo schermo

00:29:00perché ricordate che non ha preso la

00:29:01tutta una serie appena preso questi primi tre

00:29:02numeri e lì si può vedere 14 schioccato

00:29:04ora se si vuole entrare anche in

00:29:06qui e diciamo che vogliamo aggiungere

00:29:08un altro valore al quinto dell’indice

00:29:11lotteria numero di punti inserto Potremmo allora

00:29:15andare lotteria num vettore

00:29:17inizio che è l’inizio della

00:29:19vettore più cinque per arrivare alla quinta

00:29:21indice e poi mettere 44 all’interno di là noi

00:29:24potrebbe poi saltare giù qui per cinque e

00:29:25vedere il 44 pop dot pushback sta per

00:29:29aggiungere un valore alla fine del nostro vettore in modo

00:29:32spingere indietro e diciamo che vogliamo mettere

00:29:3464 in là poi vogliamo definito come

00:29:37si può vedere il vettore ridimensiona abbiamo poi

00:29:39voluto trovare quel valore finale possiamo

00:29:42richiamare e sarebbe ottenere per noi come

00:29:44è possibile vedere proprio lì pop torna è

00:29:46andando a rimuovere il valore finale è ben

00:29:49nessun punto nel fare ciò che in questo

00:29:50situazione sarebbe 64 e allora potremmo

00:29:52ottenere il primo valore nel vettore da

00:29:55chiamando passo indietro davanti abbiamo potuto ottenere il

00:29:58ultimo elemento da richiamare naturalmente

00:30:00vuoto sta per restituire zero se il

00:30:03vettore non è vuoto e un 1 o true

00:30:07quando è vuoto e infine se

00:30:09abbiamo voluto per ottenere la dimensione del nostro vettore

00:30:12possiamo farlo con sospiri c’è una

00:30:14riassunto di tutto ciò che possiamo fare con i vettori

00:30:16ora diamo uno sguardo a quello che possiamo fare

00:30:18con le funzioni all’interno di un C ++ ora la tua

00:30:21funzioni sono

00:30:22in realtà andando a comparire davanti la vostra

00:30:24funzione principale ed è fondamentalmente solo ha

00:30:26il tipo di ritorno in modo diciamo che abbiamo

00:30:28voleva avere una funzione che ha aggiunto

00:30:30numeri avremmo il nostro tipo di ritorno

00:30:32per la nostra funzione, se non ha avuto un

00:30:34Tipo di ritorno avrebbe vuoto invece

00:30:36di interi e poi andremo a

00:30:37definire i tipi di dati per i nostri attributi

00:30:41che stanno per essere ricevuti dal nostro

00:30:43funzione, in modo che possa um potremmo anche impostare

00:30:45in su in modo che questa funzione avrebbe un

00:30:47valore di default che significa che in realtà si

00:30:50Non avrebbe dovuto inviare un secondo attributo

00:30:51in quella situazione l’unica cosa che

00:30:54quello che dovete fare è se si fa questo è tutto

00:30:56delle vostre funzioni che hanno un difetto

00:30:58valore o tutti i tuoi attributi

00:30:59hanno un valore di default deve venire scorso

00:31:01quindi questo deve venire prima che così

00:31:03questa è l’unica regola lì e questo è

00:31:04noto anche come un prototipo di funzione che

00:31:07potrebbe poi andare e digitare il valore combinato

00:31:10è uguale alla prima num più seconda num

00:31:14memorizzare che in là e quindi restituire il

00:31:17valore combinato e l’ho fatto in questo modo così

00:31:20che ho potuto dimostrare qualcosa di diverso

00:31:21si potrebbe prendere questo qui e mettere

00:31:23è proprio qui nella parte di ritorno

00:31:25proprio lì non si dispone di creare un

00:31:27nuova variabile solo per eseguire che

00:31:29un’altra cosa che voglio dimostrare

00:31:30visto che sono qui e non all’interno del principale

00:31:33è che siete in grado di sovraccaricare

00:31:34funzioni che sostanzialmente significa che puoi

00:31:36utilizzare esattamente lo stesso nome ma diversi

00:31:38Attributi così ho potuto entrare qui anche

00:31:41anche se devo aggiungere già numeri

00:31:42in realtà si tratta solo di copiare il tutto

00:31:44incollarlo in là quindi non aggiungiamo i numeri

00:31:46due volte è bene avere aggiungere i numeri dei

00:31:48unico problema è che dobbiamo avere

00:31:49diversi attributi all’interno di qui

00:31:51Quindi diciamo che abbiamo secondo num e noi

00:31:54hanno anche un altro numero intero che sta

00:31:56di essere terzo num e come ho detto prima

00:31:58non abbiamo bisogno di tutto quello che potevamo semplicemente andare

00:32:00tornare ed eseguire il nostro diritto aggiunta

00:32:02all’interno di qui

00:32:03secondo num terzo num e ritorno che ora

00:32:06facciamo un salto verso il basso all’interno della principale e

00:32:07in realtà chiamare queste funzioni se io

00:32:09non ha menzionato prima che le funzioni

00:32:10in sostanza permettono di riutilizzare codice e

00:32:12anche aggiungere un certo livello di organizzazione

00:32:16al codice ecco aggiungere nums Sono

00:32:19passando in un solo ho intenzione di utilizzare il

00:32:20il valore predefinito pari a zero non stanno andando

00:32:22a passare nulla e solo per dimostrare

00:32:23e poi vi farò vedere l’altro come

00:32:25bene a numeri uno a cinque

00:32:28cinque e sei e anche se è possibile vedere se io

00:32:30eseguire che proprio lì hai uno e

00:32:32dodici pop torna sullo schermo andiamo

00:32:34e creare un po ‘più complicata

00:32:36funziona qui e questo è fondamentalmente ciò che

00:32:38che chiamano una funzione ricorsiva e questo

00:32:40normalmente è dimostrata usando la

00:32:42ottenendo di fattoriale in modo che è quello che farò

00:32:44fare

00:32:45ottenere fattoriale int numero e questo è

00:32:48sarà una funzione che si chiama

00:32:49da dentro di sé suona modo più

00:32:51complicato di questo così ho intenzione di andare

00:32:54e creare un intero chiamato somma poi

00:32:57Io vado a dire che se il numero che è

00:32:59sta per essere superato all’interno di qui è

00:33:01uguale a uno, allora voglio avere un po ‘

00:33:03pari ad un importo LS sta per essere uguali

00:33:07per ottenere fattoriale salvare chiamare su se stessa

00:33:10dall’interno di se stesso e qui sto andando

00:33:11per ottenere un numero di volte meno uno

00:33:14questo sta per ottenere il nostro fattoriale

00:33:16perché qui stiamo andando poi a tornare

00:33:18riassumere modo in modo molto veloce per ottenere il

00:33:21fattoriale di un numero e fondamentalmente ciò che

00:33:24sta succedendo qui è proprio qui ti

00:33:26scendere a questa parte questa è la prima

00:33:28tempo attraverso questa funzione e diciamo

00:33:29numero è pari a tre bene in quel

00:33:32situazione ottenere fattoriale viene chiamato con

00:33:35il valore di tre sarebbe effettivamente due

00:33:37facciamo solo concentrarsi questa immagine di quello di destra

00:33:39qui così a tre meno uno è uguale a due

00:33:42in quella situazione sta andando a restituire un

00:33:45valore di due e poi andremo a

00:33:47moltiplicare che tre tempi così proprio qui

00:33:50ogni volta che stiamo attraversando vostro il

00:33:51seconda volta questa volta abbiamo intenzione di essere

00:33:52passando due nella ottenere fattoriale così

00:33:55ci siamo e due meno uno sta andando

00:33:58essere uguale a uno e in questa situazione

00:33:59questo sta per restituire il valore di una

00:34:02e ottenere fattoriale in questa situazione

00:34:04ogni volta che viene qui la terza volta

00:34:05numero sta per essere uguale ad un così

00:34:07somma sta per essere uguale a uno e

00:34:09che sta andando a finire che le funzioni

00:34:10esecuzione e poi appena sorta di

00:34:12rimbalzare indietro fino all’inizio in modo

00:34:14quello che stiamo andando a sinistra con in questo

00:34:16situazione è che questo sta per tornare un

00:34:18che sta per essere momenti moltiplicato

00:34:19due che a destra qui in realtà va

00:34:22proprio qui e poi ci moltiplichiamo che

00:34:242 volte tre, che sta per dare noi

00:34:26il nostro valore finale di sei e andiamo

00:34:28di qui e andiamo in realtà eseguirlo

00:34:30fare in modo che questo è quello che fa

00:34:31e come scoprire è quello di andare fattoriale

00:34:34di 3 è e quindi chiamare il telefono

00:34:38ottenere fattoriale passando il valore di tre

00:34:40e mi assicurerò che vengo qui e

00:34:42ha il valore restituito essere un intero

00:34:44proprio lì e poi anche venire qui

00:34:46e rimuovere questa piccola parentesi ho messo

00:34:48in lì per caso se eseguiamo esso

00:34:49si può vedere fattoriale tre è di sei

00:34:51esattamente come abbiamo dimostrato qui

00:34:53c’è una carrellata di funzioni all’interno di

00:34:56C ++ ora voglio coprire file di I / O o come

00:34:59per leggere e scrivere i file utilizzando

00:35:01di testo o di una macchina binaria leggibile quindi sono

00:35:03andando a creare una stringa qui vado

00:35:05chiamare questa citazione di Steve è pari a

00:35:08e dire un giorno senza sole è come

00:35:12sai notte ora che cosa sto andando avere

00:35:15da fare è creare un flusso di file di output per

00:35:17creare questo file se non esiste o

00:35:20quello che farà è creare una funzione o

00:35:22creare un file se non esiste io sono

00:35:24andando a chiamarlo scrittore e ho intenzione di

00:35:26definire il nome che voglio salvare questo

00:35:29il testo in e ho intenzione di chiamarlo Steve

00:35:30citazione dot txt e poi andare a verificare

00:35:32che il flusso di file è stato creato in modo che

00:35:35Sarò in grado di scrivere il file se non

00:35:37Ho intenzione di mettere fuori un messaggio di errore

00:35:39e poi se vogliamo segnalare che un

00:35:41Errore possiamo restituire un

00:35:43uno negativo in questa situazione else if

00:35:46il flusso di file è aperto questo significa che

00:35:48può scrivere sul file ed è molto

00:35:50semplice per scrivere il testo al file basta andare

00:35:51scrittore e la stringa che si desidera scrivere

00:35:54e poi mi butto una nuova linea in là

00:35:57alla fine e quindi molto importante che si

00:35:58anche voler entrare e chiudere quel file

00:36:01streaming alla fine ho intenzione di continuare a

00:36:02andare qui perché abbiamo avuto modo di leggere

00:36:04da esso diciamo che anche si voleva

00:36:06per venire qui il nostro flusso di file è

00:36:08CHIUSO stiamo andando a creare un altro

00:36:10e mi limiterò a chiamare questo scrittore troppo e

00:36:12poi in questa situazione che cosa stiamo andando

00:36:13di fare è che andremo a definire che abbiamo

00:36:16voglia di scrivere al testo citazione di Steve

00:36:19file e poi qui stiamo andando a dire

00:36:21che vogliamo aggiungere quello che stiamo andando

00:36:23Operazioni successive alla fine di ciò che è già

00:36:25c’è ora c’è un intero gruppo di

00:36:27simboli diversi che possono utilizzare l’uso qui per

00:36:29fare cose diverse con i file come I

00:36:32appena detto con iOS abbiamo intenzione di essere

00:36:34in grado di aggiungere alla fine del file

00:36:36con iOS binario stiamo andando per essere in grado

00:36:38per trattare il file come se fosse iOS binari

00:36:40in sta per aprire un file di input per leggere

00:36:42quello che stai andando a vedere qui un minuto

00:36:43tronco IOS è il difetto che succede

00:36:46ogni volta che non si utilizza uno di questi

00:36:47simboli e quindi iOS fuori sta andando

00:36:49Aperto

00:36:49off per scrivere l’uscita ma in questo

00:36:52situazione che andremo a essere un’attesa

00:36:53e ancora una volta stiamo andando ad avere bisogno di

00:36:55entrare qui e verificare che questo file

00:36:57stream è già aperta e io sono solo

00:36:58andando a copiare questa pasta che in là

00:37:00ma assicurarsi che questo sia giusto o qui

00:37:02invece che a destra ci si va e questo

00:37:05sta per essere scrittore 2 che andremo a

00:37:06sputare fuori un errore ancora una volta se il file

00:37:08stream non è stato aperto e poi da aggiungere

00:37:10in questa situazione abbiamo intenzione di andare

00:37:12scrittore e poi diciamo che vogliamo

00:37:14di mettere su una nuova linea di barra rovesciata e N

00:37:18poi un trattino e quindi digitare Steve

00:37:20Martin abbiamo poi potuto entrare e dire

00:37:22scrivere o chiudere e là che va bene

00:37:25così abbiamo scritto e ci siamo accodati e abbiamo

00:37:27creato il file e ha fatto tutto quello che ora

00:37:29Ho intenzione di creare un personaggio che è

00:37:30intenzione di tenere ciascuno dei singoli

00:37:32personaggi che stanno andando a leggere dalla nostra

00:37:33di file e stiamo andando a leggere queste

00:37:35caratteri utilizzando un flusso di file di input in modo

00:37:37flusso di file di input e ho intenzione di chiamare

00:37:40questo lettore ed è necessario raccontarla

00:37:42esattamente quello file che si sta andando ad essere

00:37:44la lettura e poi ho intenzione di controllare

00:37:45se quel fiume sta per essere aperto solo

00:37:48come abbiamo fatto prima con il lettore

00:37:49all’interno di lì venire qui e di stampa

00:37:51errore nuovamente ruotare Erica negativa altro

00:37:55sappiamo che abbiamo ottenuto il nostro flusso aperto e

00:37:57saremo in grado di leggere da quel file e

00:37:59stiamo andando a utilizzare un ciclo for in questo

00:38:00situazione per leggere ogni carattere da

00:38:02il torrente fino ad arrivare alla fine del

00:38:05la linea così ho intenzione di andare in I è

00:38:06uguale a zero, allora ho intenzione di andare, mentre

00:38:09il lettore non arrivare alla fine del

00:38:11il file che andremo a continuare a leggere

00:38:13personaggi e poi chiameremo lettore

00:38:15arrivare a ottenere la lettera successiva della produzione

00:38:17che vogliamo e poi in questa situazione

00:38:19diciamo solo che vogliamo stampare

00:38:20che fuori per il tipo di schermo a lettera

00:38:22poi dopo il loop per tutto fatto con

00:38:24si va vedere fuori fino e poi ancora una volta

00:38:27chiudere il lettore se lo facessimo tutti

00:38:29giorno giusto senza sole è come te

00:38:31conoscere la notte in modo da poter vedere ha funzionato

00:38:33e queste sono tutte le cose diverse

00:38:34si può fare e per quanto riguarda la lettura e la

00:38:36la scrittura dei dati utilizzando C ++ ho intenzione di

00:38:39tocco brevemente gestione delle eccezioni e

00:38:41la gestione delle eccezioni in pratica si consente

00:38:43al fine di evitare potenziali problemi in questo

00:38:46situazione Sto solo andando a concentrarsi su un

00:38:47che è una divisione per zero che

00:38:50potrebbe causare tutti i tipi problema ora

00:38:52ogni volta che si vuole coprire qualcosa

00:38:53che potrebbe causare un’eccezione o un

00:38:55errore che si vuole essere in grado di catturare

00:38:56si sta andando a circondare il codice che

00:38:58potrebbe potenzialmente causare che l’aria all’interno

00:39:00di ciò che viene chiamato un blocco try e poi

00:39:02quali sono state

00:39:02fare sta per impostare un’istruzione if

00:39:04qui dentro che dice che se il numero è

00:39:07non uguale a zero anche in tale situazione

00:39:11possiamo dire C fuori e dividere per il numero

00:39:14come abbiamo fatto lì, ma come si può vedere

00:39:16che sta per causare un errore e

00:39:19stiamo andando mai arrivare

00:39:20altrimenti andremo a dire il numero tiro ora

00:39:23questo tiro è andare a guardare per la pesca

00:39:26e la zona di cattura è dove stiamo andando

00:39:29per prendere il numero che è stato immesso

00:39:31non c’è bisogno di fare questo, ma aiuta in modo

00:39:34che abbiamo il messaggio di errore fa

00:39:35Ragione e allora potremmo fare qualcosa

00:39:36come il numero non è valido e quindi forse

00:39:40avere la maschera o chiedere loro di nuovo

00:39:42potete vedere qui se corriamo a zero non è

00:39:44valido così invece di provocare un errore

00:39:46qui mettendo questo all’interno di un

00:39:48cercare di blocco e poi gettando se

00:39:50sarebbe effettivamente immettere un 0 che provoca

00:39:52potenziali errori stiamo invece andando a

00:39:54catturare il basso in questo settore proprio qui

00:39:55e risolvere e mantenere il nostro programma dal

00:39:57schiantarsi così che è una breve spiegazione

00:39:59di eccezioni ok ora parliamo di

00:40:02puntatori ora quando i dati vengono memorizzati è

00:40:04memorizzato in una casella di dimensioni appropriate

00:40:06che si basa fuori del suo tipo di dati solo

00:40:08come abbiamo coperto in precedenza abbiamo qui

00:40:10un intero e qui abbiamo un carattere

00:40:11ora come abbiamo fatto prima abbiamo intenzione di essere

00:40:14in grado di venire qui e utilizzare sizeof per

00:40:16determinare il numero di byte che i dati sono

00:40:18andando a prendere su e possiamo vedere qui

00:40:20ogni volta che si corre il programma che il

00:40:21intero sta andando a prendere 4 byte e

00:40:23il personaggio sta andando a prendere 1 byte

00:40:25ora si sta andando ad essere in grado di fare riferimento a

00:40:26questa scatola o l’indirizzo di memoria in cui

00:40:29tutti i dati sono memorizzati con ciò che è

00:40:31chiamato l’operatore di riferimento che è

00:40:33una borsa M e così abbiamo potuto entrare qui

00:40:35e andare a vedere fuori e la mia età si trova a

00:40:39e poi utilizzare l’operatore di riferimento

00:40:41seguito da mia età e quando eseguiamo

00:40:44che si può vedere l’indirizzo di memoria

00:40:45proprio qui ora ciò che è veramente interessante di

00:40:47questo è ogni volta che non usiamo puntatori

00:40:50o non usiamo gli operatori di riferimento e

00:40:53cambiamo il valore di una variabile in un

00:40:55regolare vecchi funzione che cambia di

00:40:57valore non portare su di essa è persa e

00:41:00il motivo per cui è ogni volta che usiamo

00:41:02funzioni regolari ciò che siamo, in sostanza,

00:41:04facendo sta passando un valore in quella

00:41:06funzione quindi, anche se abbiamo avuto lo stesso e

00:41:10questi e siamo passati in alcuni come un

00:41:15variabile in funzione chiamata add

00:41:17questi proprio come questo che cosa sta andando

00:41:19accadere è il valore delle somme così diciamo

00:41:22abbiamo un intero qui sum intero è

00:41:24pari a 5 e passiamo un po ‘in l’add

00:41:29questi funzionano bene se cambiamo il

00:41:31valore della somma e non passiamo indietro

00:41:34somma è ancora in corso per essere uguale a 5

00:41:36perché stiamo passando un valore con

00:41:39operatore di riferimento e con puntatori in

00:41:41generale quello che stiamo andando a essere in grado di

00:41:42fare invece è passare riferimento e qualsiasi

00:41:45modifica apportata dentro c’è

00:41:46intenzione di mostrare ora un puntatore sta per

00:41:50essere in grado di memorizzare un indirizzo di memoria di

00:41:52ricreare la mia età per dimostrare questo e

00:41:55ogni volta che si sta definendo un puntatore si

00:41:56semplicemente utilizzare lo stesso tipo di dati

00:41:58seguita da una stella e diremo età

00:42:01puntatore come questo è uguale e poi

00:42:03avete intenzione di usare il riferimento

00:42:05all’operatore di passare che oltre Proprio come

00:42:07prima che stiamo andando ad essere in grado di accedere

00:42:08l’indirizzo di memoria con questo puntatore di

00:42:11puntatore semplicemente digitando in età PTR ma

00:42:14saremo anche in grado di risolvere il riferimento di ottenere

00:42:17i dati a tale indirizzo di memoria in modo faremo

00:42:20dire dati a indirizzo di memoria e come si

00:42:23dereference è quello di mettere stelle di fronte al

00:42:26puntatore età giusta come quella si vedrà

00:42:29qui con questo indicatore sarà ora in grado

00:42:31per ottenere l’indirizzo di memoria, nonché la

00:42:34dati memorizzati in tale memoria

00:42:36affrontare diamo uno sguardo a come gli array

00:42:39Beh diciamo noi abbiamo i nostri numeri male

00:42:41matrice come abbiamo usato in precedenza abbiamo

00:42:43possono poi andare int stella per creare un puntatore

00:42:46e chiameremo questo puntatore numero

00:42:48è uguale a cattive nums

00:42:51ciò che è pulito qui è che andremo a

00:42:53effettivamente in grado di incrementare mediante

00:42:55la nostra gamma usando solo notazione abbreviata

00:42:58come plus plus e minus minus in modo che possiamo

00:43:01andare a vedere fuori indirizzo del puntatore numero di serie

00:43:04e il valore e quindi per ottenere il reale

00:43:07valore della matrice possiamo andare serie insensibile

00:43:10puntatore e quindi chiudere che off e poi

00:43:12entrare e andare puntatore intorpidito più

00:43:15più per ottenere il valore successivo nella nostra gamma

00:43:18rimbalzo che lì dentro e non ci si può

00:43:20vedere saltato in là afferrato 4 e 13 come

00:43:23così come gli indirizzi di memoria e come noi

00:43:24visto in precedenza un numero intero occupa 4

00:43:26Byte si può vedere la differenza

00:43:28la memoria si rivolge proprio lì, quindi

00:43:29stai imparando su come questa roba è

00:43:31immagazzinato all’interno di qui e qualcos’altro

00:43:33che è interessante è un nome di matrice viene

00:43:36solo un puntatore alla matrice così abbiamo potuto

00:43:39entrare ed indirizzo e mettere l’array

00:43:42nome da solo all’interno di di lì a gnomi

00:43:44per ottenere il valore che è memorizzato lì e

00:43:47si può vedere che funziona anche vedere lo stesso

00:43:49indirizzo di memoria stesso valore in modo da qualcosa

00:43:51interessante pensare a come ho detto

00:43:53precedentemente ogniqualvolta si passa una variabile

00:43:55a funzionare si sta passando per valore

00:43:56però ogni volta che si passa un puntatore ad un

00:43:58funzione che si sta effettivamente passando un

00:44:01riferimento che può essere modificato in modo cerchiamo di

00:44:03saltare qua e creiamo una funzione

00:44:05per dimostrare esattamente come funziona

00:44:07questo non ha intenzione di tornare nulla di così

00:44:09Ho intenzione di tirarla su di vuoto all’interno

00:44:10lì e io ho intenzione di dire farmi giovane

00:44:13e questo sta per ricevere un puntatore

00:44:16così ho intenzione di mettere int with a star

00:44:18dopo e poi l’età del genere e poi

00:44:21cerchiamo di tirare fuori qui sullo schermo del

00:44:23età precedente ho usato per essere così e

00:44:28per ottenere il valore di età ho messo una stella e

00:44:30età, perché altrimenti è la memoria

00:44:32l’indirizzo deve mettere quel negozio lì

00:44:34ma poi posso anche andare in e il cambiamento

00:44:35tale valore mettendo stella e l’età è

00:44:38pari a 21 non restituiscono nulla non

00:44:40hanno a che fare nulla altrimenti poi posso

00:44:42venire qui e chiamare mi fanno giovane se

00:44:45Voglio passare un riferimento a quel ragazzo

00:44:48passaggio per riferimento che è tutto quello

00:44:50significa che posso farlo e quindi ho potuto mettere

00:44:52Sono e poi basta un assegno o verificare che

00:44:55in realtà cambiato che l’età si può fare

00:44:58questo e si può vedere che ho usato per essere 39

00:45:01che è venuto dalla funzione poi abbiamo

00:45:02cambiato a 21 all’interno della funzione

00:45:05e poi si può vedere qui che è

00:45:06cambiato globalmente possono anche venire qui

00:45:08e ancora una volta questo e commerciale sta andando

00:45:10per indicare che il riferimento di età sarà un

00:45:12riferimento alla variabile assegnata in modo

00:45:14c’è differenza tra un riferimento

00:45:16di riferimento e un puntatore che sto andando

00:45:19per ottenere più in quando si dovrebbe utilizzare uno

00:45:21quando si dovrebbe utilizzare un altro io sono

00:45:22sarà in grado di andare a vedere fuori sei

00:45:24in realtà intenzione di utilizzare i riferimenti più

00:45:26che si utilizza puntatori come ho detto che è

00:45:28in arrivo un secondo un’altra cosa che è

00:45:30interessante è che potremmo prendere questo

00:45:32riferimento e incrementa e vedere che

00:45:34che anche cambiato il mio

00:45:37destra come questo si può vedere qui è il mio

00:45:3921 anni ecco la mia età di 22 di nuovo

00:45:42a livello globale stiamo cambiando tutti coloro poi

00:45:44creiamo un’altra funzione di questo

00:45:45sta per essere chiamato agire la vostra età solo per

00:45:47passare il riferimento e mostra

00:45:49differenza tra di passaggio che

00:45:51di riferimento e si occupano di puntatori venire

00:45:53qui e creare un’altra funzione è

00:45:55anche non andare a restituire nulla solo

00:45:56per dimostrare che nulla è lo scambio di mani

00:45:59agire la vostra età, tranne stiamo passando un

00:46:02fare riferimento a questo tempo in modo che andremo a

00:46:03mettere la commerciale all’interno di lì e

00:46:05Sto solo andando a mettere l’età ancora lì

00:46:06Non importa quello che ho messo e io sono qui

00:46:08solo andando a dire che l’età è pari al 39

00:46:11marcia indietro di nuovo qui solo dimostrando

00:46:13una differenza tra passando da

00:46:14riferimento e di passaggio per puntatore e

00:46:16potrebbe andare avanti e dimostrare che è ancora

00:46:18il cambiamento di età è pari a Ndele e là

00:46:21si può vedere che ha effettivamente cambiare così

00:46:23in pratica si potrebbe chiedere se stessi bene

00:46:25ogni volta che si sta decidendo se si

00:46:26desidera utilizzare puntatori o riferimenti quando

00:46:28si dovrebbe utilizzare che ben fondamentalmente si

00:46:30dovrebbe utilizzare i puntatori se non si vuole

00:46:32hanno inizializzare a quello di dichiarazione

00:46:35che significa è che si può vedere a destra qui

00:46:37sto definendo stiamo inizializzazione quello che sto

00:46:41riferimento ogni volta che sto usando la

00:46:43opzione di riferimento ogni volta che mi occupo

00:46:45con i puntatori non ho bisogno di

00:46:47immediatamente inizializzare e poi in cima

00:46:50di che con un puntatore ho intenzione di essere

00:46:51in grado di assegnare un’altra variabile così

00:46:54un puntatore sta per essere in grado di affrontare

00:46:55con più di uno, mentre un riferimento è

00:46:57andando ad ottenere questo riferimento alla presente

00:46:59una variabile ed essere attaccato con esso quindi se

00:47:01non c’è bisogno di essere in grado di cambiare

00:47:02Qualunque cosa si sta andando ad essere indicando

00:47:04utilizzare un riferimento che è praticamente la

00:47:06regola ferrea così e questa è la base di

00:47:09puntatori stiamo andando per ottenere più in

00:47:11qui in un secondo, ma ora sto andando

00:47:12di saltare oltre e parlare di classi ora

00:47:14adesso programmazione orientata agli oggetti quali

00:47:16stiamo cercando di fare è il modello del mondo reale

00:47:18oggetti come un animale in codice e come

00:47:22fate che è ci pensate bene che cosa

00:47:24rende un oggetto specifico un oggetto ben

00:47:27ogni oggetto ha attributi quali

00:47:30altezza e peso e qualsiasi altra cosa e si

00:47:34ha anche funzionalità in modo che possa funzionare e

00:47:38si può mangiare solo per essere veramente semplice

00:47:40c’è anche questi attributi stanno per

00:47:42essere modellato nelle variabili e questi

00:47:45capacità stanno per essere modellato in

00:47:47le funzioni o

00:47:49la modalità stessa cosa solo un diverso

00:47:52nome in modo che cosa ho intenzione di fare qui dentro

00:47:54della mia classe è ho intenzione di avere un po ‘di

00:47:57queste cose siano privati e da privati

00:48:00quello che sto dicendo è che tutto ciò che è

00:48:03segnato privato per quanto riguarda gli attributi

00:48:05o variabili è solo andare a essere in grado di

00:48:07essere cambiato da funzioni all’interno del mio

00:48:11di classe e lo facciamo solo per tenerli

00:48:14protetto e questo si chiama

00:48:15incapsulamento così ho intenzione di avere il mio

00:48:18nome altezza e peso tutti essere privato

00:48:21e mentre io sono qui potrei pure

00:48:23parlare di variabili statiche in fondo se

00:48:25si mette statica di fronte a qualcosa tutto

00:48:28che significa che questo valore variabili

00:48:31sta per essere condiviso da ogni oggetto di

00:48:34tipo di animale che viene sempre creato in modo

00:48:36diciamo che voglio tenere anche traccia

00:48:38del numero di animali che sono

00:48:41creato dalla mia classe ben non sarebbe

00:48:44ha senso che un animale conterebbe

00:48:46questo è un altro motivo per cui abbiamo statica

00:48:48qui perché le variabili statiche anche

00:48:50normalmente sono attributi che la classe

00:48:54oggetto non avrebbe quindi vogliamo essere

00:48:56in grado di contare il numero di animali che

00:48:57vengono create ma noi non vogliamo

00:48:59effettivamente essere il tipo di animale definita

00:49:02essere in grado di farlo e che ci porta a

00:49:03bene pubblico se abbiamo variabili che

00:49:06sono privati stiamo andando ad avere per avere

00:49:08metodi pubblici che stanno per essere in grado

00:49:10per accedere ai valori all’interno di là così

00:49:13stiamo per avere qualcosa di simile get

00:49:14altezza ci andiamo e sono in realtà

00:49:16andando a creare proprio questo qui su un

00:49:18linea e quando questo è chiamato è

00:49:20andando a restituire il valore memorizzato

00:49:22per il mio oggetto animale a chi chiama

00:49:25per esso e possiamo anche fare la stessa cosa

00:49:27con peso e questo è anche

00:49:29incapsulamento stiamo mantenendo tutti i nostri

00:49:32i dati protetti e questo sta per

00:49:33restituire una stringa

00:49:34ogni volta che la funzione di nome si chiama get

00:49:36e noi possiamo solo andare di ritorno e il nome e

00:49:39ci andiamo, ma quello che vogliamo davvero

00:49:41facciamo ogni volta che abbiamo a che fare con

00:49:42incapsulamento è di proteggere i valori che

00:49:45stanno per essere immagazzinata in modo che potrebbe

00:49:47vogliono venire qui e impostare l’altezza

00:49:49e diciamo che decidiamo che abbiamo

00:49:51vogliono solo che siano in grado di entrare in un

00:49:53altezza ragionevole potremmo fornire un

00:49:55controllare all’interno qui per verificare che il

00:49:57altezza animale ha un senso e in caso contrario

00:49:59scartarlo, ma in questa situazione io

00:50:02appena

00:50:02che è piacevole e semplice anche intenzione di fare

00:50:04esattamente la stessa cosa qui per la

00:50:06peso così il peso e cerchiamo di avere questo

00:50:09kg Video kg di peso e di

00:50:13Naturalmente non importa se si mette

00:50:14centimetri o chilogrammi o ciò che si mette

00:50:16all’interno di lì e setName dire animali

00:50:20nome in questo momento dobbiamo avere questa sia

00:50:22diverso da questo, ma ho intenzione di

00:50:24vi mostrerà come cambiare la situazione qui in un

00:50:25secondo nome animale proprio lì

00:50:27tutto il resto sembra perfettamente bene e

00:50:29allora potremmo anche creare un altro

00:50:31funzione all’interno di qui chiamiamolo questo

00:50:33a tutti e qui stiamo creando un

00:50:36prototipo di una funzione che siamo

00:50:37andare a dichiarare qui in un secondo sei

00:50:40andare a vederlo e questo è il modo in cui

00:50:41dichiarare un prototipo di un’altra cosa che abbiamo

00:50:43vorrebbe avere è un costruttore e

00:50:45ciò che un costruttore è in primo luogo fuori il suo nome

00:50:48sta per iniziare con qualunque sia la

00:50:49Il nome di classe è e allora qui siamo

00:50:51andando a creare un prototipo di questo e

00:50:53questo sta per essere la funzione che è

00:50:55sta per essere chiamato ogni volta che un oggetto è

00:50:57creato e quindi passerà in altezza

00:51:00il peso e il nome e il

00:51:01costruttore sta per gestire la creazione di

00:51:04ogni oggetto se abbiamo un costruttore di noi

00:51:06tutto show dovrebbe avere un distruttore ed è

00:51:08ha appena quel piccolo segno tilde lì

00:51:10ancora una volta questo sta per essere un

00:51:11prototipo dove sto andando a costruire il

00:51:13porta dichiarare quello attuale basso

00:51:15e poi diciamo che vogliamo avere

00:51:16un altro costruttore che non riceve

00:51:18niente e questo è un esempio di

00:51:20sovraccarichi e sovraccaricare una funzione

00:51:23come ho parlato in precedenza il nome

00:51:25può essere lo stesso, ma gli attributi bisogno

00:51:28di essere diversi ecco abbiamo due INTZ

00:51:29e una stringa qui ci sono sempre passato

00:51:31Niente

00:51:32i membri c’è anche protetti quando

00:51:34in pratica ogni volta che abbiamo a che fare con

00:51:35protetto quello che stiamo dicendo è che

00:51:37nulla contrassegnato come protezione sta per

00:51:39a disposizione dei membri della stessa

00:51:40classe così come sottoclassi ma niente

00:51:43altro e potremmo anche venire qui e

00:51:45definire un metodo statico e statico

00:51:48metodo viene annullata perché sono

00:51:51allegato alla classe e non al

00:51:53oggetto come si sta andando a vedere sto andando

00:51:55visualizzare in un secondo come realtà

00:51:56chiamare un metodo statico e in questo

00:51:58metodi statici situazione può anche solo

00:52:01Accesso variabili membro statico come questo

00:52:04ragazzo abbiamo qui proprio lì, quindi abbiamo

00:52:07stanno per avere questo metodo

00:52:08specificamente in grado di restituire la

00:52:10numero di animali

00:52:11che vengono creati qui andiamo e questo

00:52:14volta non andremo a fare un prototipo

00:52:15non ci resta che in realtà fare ciò che è

00:52:18dovrebbe fare lì è anche

00:52:20infine, creeremo una stringa di due che

00:52:22sta per stampare tutte le

00:52:23informazioni che abbiamo sui nostri animali ok

00:52:26così siamo andati e abbiamo dichiarato la nostra classe

00:52:28è dopo questa piccola parentesi graffa

00:52:30stiamo andando a mettere un punto e virgola e ora

00:52:32stiamo andando a dichiarare tutto in modo che il

00:52:35prima cosa che andremo a dichiarare

00:52:36è il nostro numero statica degli animali e come

00:52:39ci riferiamo a variabili statiche è mettere il

00:52:41nome della classe seguito da questi due punti

00:52:43proprio qui e quindi qualunque sia il nome di

00:52:45si dice che è legato alla classe che ha

00:52:48assolutamente niente a che fare con l’oggetto

00:52:50stesso possiamo quindi definire il prototipo

00:52:52Metodo per il set tutto così impostare tutto è giusto

00:52:55Qui stiamo andando ad andare e definirlo

00:52:58lì che era solo un prototipo e

00:52:59stiamo andando a farlo mettendo un vuoto

00:53:02animale e quindi impostare tutti così e

00:53:05allora dobbiamo definire esattamente che cosa è

00:53:07essere passato a qui in modo che andremo a

00:53:09avere due pollici per l’altezza e la

00:53:10peso così come la stringa del nome questo

00:53:13in fondo fa quello che fa il costruttore

00:53:14ma volevo solo vedere una cosa

00:53:16Ora, se si desidera fare riferimento a un oggetto

00:53:19determinata altezza e non solo un generico

00:53:22tipo di altezza si mette questo all’interno di

00:53:24qui e la ragione dobbiamo farlo

00:53:26è ogni volta che la classe viene creata lì

00:53:28sono oggetti creati animali quindi se abbiamo

00:53:31utile fare riferimento agli animali che conosci

00:53:33gli oggetti animale specifico versione o

00:53:36il valore per l’altezza dobbiamo mettere questo in

00:53:39davanti ad esso e ci andiamo e ora siamo

00:53:41può anche fare la stessa cosa per il peso

00:53:43e anche il nome basta cambiare questo a peso

00:53:46e cambiare questo al peso e abbiamo potuto

00:53:48hanno anche venire qui e usato questo

00:53:50qui vedere come abbiamo dovuto usare centimetri

00:53:52invece di avere altezza o peso o

00:53:55qualunque sia all’interno di lì, se vogliamo

00:53:56abbiamo usato questo ci sarebbe stato in grado

00:53:58per andare in giro che solo un modo per riferirsi

00:54:00in modo che la si conosce il codice in realtà

00:54:02sa che cosa si sta cercando di codice o quello

00:54:04si sta cercando di fare si può anche venire in

00:54:06qui e cambiare la situazione variabile statica

00:54:08Ricordiamo che stiamo creando o cambiando la

00:54:11I valori qui e poi ancora una volta siamo

00:54:13fondamentalmente intenzione di fare questo con il

00:54:14costruttore come bene e ricordare il

00:54:16costruttore viene chiamato ogni volta

00:54:18un oggetto animale si crea quindi non abbiamo

00:54:21andare e sta andando ad essere chiamato

00:54:22Ho intenzione di ottenere questo diritto qui int

00:54:25attendere nome di stringa e questo è fondamentalmente

00:54:28intenzione di fare esattamente la stessa cosa che

00:54:30questo non facciamo solo andare in là pasta

00:54:32in là e si può vedere che

00:54:33fondamentalmente detto tutto fa esattamente lo stesso

00:54:35cosa che il costruttore non quindi non c’è

00:54:37alcun motivo per mettere in là che ho appena

00:54:39fatto solo così ho potuto mostrarvi un altro

00:54:41funzione all’interno di lì così facciamo solo

00:54:43sbarazzarsi di questo per mostrare la regolare

00:54:45funzioni e costruttori sono tutti la

00:54:47stessa cosa per il costruttore D siamo solo

00:54:49intenzione di andare animale due punti e commerciale

00:54:52animale non riceve nulla e poi

00:54:54potremmo venire qui e basta mettere un

00:54:56messaggio fuori animale otteniamo questo specifico

00:54:59Nome animale mettere questo in là nuovo nome

00:55:02e distrutto solo in modo che abbiamo un

00:55:04messaggio sullo schermo per vedere cosa c’è

00:55:05in corso abbiamo la nostra sovraccarico

00:55:07costruttore che sta per essere chiamato

00:55:09ogniqualvolta attributi vengono passati in un

00:55:11animale è ancora costruttore no

00:55:14attributi e in questa situazione abbiamo

00:55:16potrebbe anche chiamare che abbiamo creato

00:55:18un altro animale allora abbiamo i due

00:55:20stringa dove è che alla

00:55:21lì è solo dire nulla a stringa

00:55:23veniamo qui e dichiarano che

00:55:25vuoto non ottiene nulla di classe animale

00:55:27nome a stringa non riceve

00:55:29attributi e qui abbiamo potuto entrare e

00:55:31basta stampare tutte le informazioni che abbiamo

00:55:33avere sul nostro animale è e ottenere l’altezza

00:55:37per il nostro oggetto animale specifico saltare giù

00:55:40nella diapositiva successiva solo a mantenere questo pulito

00:55:41centimetri di altezza e questo ottiene l’attesa

00:55:45per esso kg di peso ea

00:55:48chiudere che off allora saremo in grado di andare

00:55:50giù nel Maine e iniziare a creare animali

00:55:52oggetto in modo per creare questa diciamo noi

00:55:54voler creare un animale di nome Fred siamo

00:55:56potrebbe poi andare in Fred e impostare il suo

00:55:59altezza per 33 impostare il suo peso a 10 e

00:56:03messo il suo nome, naturalmente, di Fred mi piace

00:56:07che basta creare un nuovo siamo animali Fred

00:56:09potrebbe poi ottenere i valori di ritorno da esso I

00:56:12andare Fred dot ottenere nome è che non siamo

00:56:15utilizzando questo qui solo per mostrare la

00:56:18differenza tra cercando di ottenere il

00:56:19dati dall’interno della classe stessa e

00:56:22poi cercando di farlo da qualche altra parte

00:56:24centimetri di altezza e Fred ottenere peso

00:56:27chilogrammi

00:56:28in lotta ci siamo e potremmo anche

00:56:31entrare e utilizzare il nostro costruttore in questo

00:56:33situazione qui stiamo usando il default

00:56:36costruttore che non c’è niente

00:56:38attributi e qui useremo il

00:56:40costruttore che fa uscire le offerte

00:56:42così passeremo nel 3615 e Tom e poi

00:56:46abbiamo intenzione di essere in grado di stampare anche fuori

00:56:47tutte le differenze tra Tom e Fred

00:56:50cerchiamo di stampare che fuori e poi basta

00:56:51cambiare questo a Tom c’è Tom c’è

00:56:54Tom c’è Tom e fatto piccolo errore

00:56:56qui facciamo solo saltare fino a impostare il nome e

00:56:58facciamo in modo cambiamo ad un

00:57:00stringa e un intero spostare un po ‘

00:57:02po ‘troppo veloce qui a volte rendono poco

00:57:04errori e c’è un nome di animale

00:57:06Questo è anche venire qui e il cambiamento

00:57:08questo nome e quindi modificare questo nome

00:57:11va bene così ci si va ora che avete visto

00:57:13che abbiamo creato un Fred e un oggetto Tom

00:57:15andiamo oltre ed eseguire che e là

00:57:17è possibile vedere fred è alto 33 centimetri

00:57:1810 kg di peso è tom 36

00:57:21centimetri 15 kg di peso

00:57:22e qui si può vedere il distruttore era

00:57:24chiamati a distruggere sia quegli oggetti

00:57:26dal momento che non abbiamo più bisogno di loro ora possiamo

00:57:28anche venire in ed ereditare tutto il

00:57:31attributi ei metodi che sono

00:57:32creato dall’oggetto animale e

00:57:35invece di utilizzarli nella nostra classe cane così

00:57:38ci andiamo solo nuovi creare un nuovo cane

00:57:40di classe e di ereditare tutto l’animale

00:57:43classi abbiamo appena messo due punti e poi

00:57:45pubblica e degli animali e questo è tutto quello che dobbiamo

00:57:47da fare e abbiamo tutto ciò che è

00:57:49definito nella classe degli animali abbiamo potuto

00:57:52venire qui di corso e di creare qualche

00:57:54quelli nuovi Quindi diciamo che volevamo avere

00:57:56una stringa suono che sta per avere la

00:58:00valore del lupo e poi potremmo anche

00:58:03entrare e creare un po ‘di pubblico

00:58:05metodi che fanno alcune cose diverse

00:58:08una cosa che sta andando ad avere a che fare è

00:58:10ottenere il suono e in questa situazione sono

00:58:13solo andando a che la stampa sul nostro

00:58:15schermo in modo suono ci andiamo perché siamo

00:58:18intenzione di avere un suono nella nostra classe cane

00:58:20e gli oggetti il ​​nostro cane che stiamo andando ad avere

00:58:22per dichiarare un nuovo costruttore che è anche

00:58:25andando ad ottenere il suono in modo int int stringa

00:58:28e la stringa mi piace che con quel

00:58:31prototipo potremmo anche venire qui e

00:58:33dichiarare un costruttore di default che non è

00:58:36di ricevere qualcosa e poi in cima

00:58:38che chiamano la superclasse di default

00:58:39costruttore come andare come questo

00:58:41e ci siamo e potremmo anche

00:58:43decidere di sovrascrivere due stringhe da quando abbiamo

00:58:46sono anche andando a stampare il

00:58:48cane suono che è tutto quello che andremo a fare

00:58:50lì e poi mettere un altro punto e virgola

00:58:53qui alla fine del corso molto importante

00:58:55per la nostra classe ora dobbiamo andare a qui

00:58:57e in realtà definire tutto ciò che era

00:58:59sta per cambiare così questo sta andando a

00:59:02essere il costruttore per il nostro cane ed è

00:59:04sta per ottenere superato il in stretto e la

00:59:08pesi interi e il nome della stringa come

00:59:12così come il marchio di stringa ora fare riferimento

00:59:15la classe degli animali qui e mettere i due punti in

00:59:18un animale e stiamo andando a dire qui

00:59:20che vogliamo che il costruttore di animale

00:59:22gestire l’altezza e il peso dal

00:59:25ha gestito così bene precedenza tuttavia

00:59:27Voglio in questo costruttore per essere in grado di

00:59:30gestire la parte del suono perché il suono

00:59:32non esiste nella classe animale e

00:59:35qui stiamo solo andando ad avere un tema

00:59:36parco così che è un ottimo modo per avere la

00:59:39costruttore animale altezza peso maniglia

00:59:41nome, perché tutti questi attributi sono

00:59:43andando ad essere condiviso e, allo stesso tempo

00:59:45basta cambiare la cosa che è diversa

00:59:46ci salva qualche spazio potrebbe anche venire in

00:59:49qui perché a stringa anche cambiato così

00:59:52andiamo qui e cambiarla e

00:59:54perché gli attributi come nome e

00:59:57altezza e peso sono stati privati ​​in animali

00:59:59Sto andando ad avere per utilizzare il metodo get

01:00:01per essere in grado di accedervi così ho intenzione

01:00:03a dire questo nome get giusto così è

01:00:06questa altezza get centimetri di altezza e

01:00:10questo ottenere kg di peso in peso e

01:00:15dice che questa è la cosa che è diverso

01:00:17saltare giù qui questo suono va bene ora posso

01:00:21dimostrano in realtà la creazione di un cane

01:00:23agli oggetti facciamo così basta andare cane e diamo

01:00:25chiamarlo individuare ho intenzione di passare a 38 16

01:00:28il suo nome è posto e il suono sta andando

01:00:31di essere lupo se anche io voglio solo

01:00:34dimostrare con metodi statici qui andare

01:00:37vedere fuori il numero di animali che

01:00:41creato animale e per chiamare una statica

01:00:43Metodo di andare ottenere insensibile degli animali

01:00:46credono che è ciò che essi chiamavano trovare

01:00:48in un secondo e ora sto anche andando

01:00:50per essere in grado di andare posto dot il suono e

01:00:53potremmo anche andare in e ottenere test di Tom a

01:00:56stringa che fondamentalmente fa con tutti

01:00:58ciò che altre cose ha fatto lassù dot posto

01:01:00a corda e solo visualizzare un altro

01:01:03cosa che potremmo anche chiamare la superclasse

01:01:05versione di un metodo andando posto degli animali

01:01:08animale e poi mettere in due punti e

01:01:11corda e dal modo in cui io continuo a chiamare

01:01:13questi due punti Questa è chiamata la portata

01:01:15operatore, se volete sapere di cosa si tratti

01:01:16davvero chiamato e, naturalmente, alla fine qui

01:01:18assicuriamo abbiamo messo la nostra istruzione return

01:01:20con zero e se eseguiamo esso è possibile

01:01:23dire che non c’è il numero di tutto

01:01:25gli animali che sono stati creati è possibile vedere

01:01:27sono le tre proprio lì e che include

01:01:29posto di essere il cane, così come Fred e

01:01:33anche Tom in modo che la ragione per cui che

01:01:35si presentò e il motivo per cui è il

01:01:37costruttore animale è stato chiamato ogni

01:01:39getta se il cane è stato creato o

01:01:41gli animali sono stati creati è possibile vedere lupo

01:01:43proprio qui è questo tizio qui

01:01:44chiamando suono get si può vedere che siamo

01:01:47chiamando a stringa su tom per stampare

01:01:49le informazioni su quello che possiamo vedere qui

01:01:51quel punto dice anche il lupo, mentre il

01:01:53animale normale non lo fa non

01:01:55funziona automaticamente e qui siamo solo

01:01:56dimostrare l’uso di chiamare a

01:02:00corda e in questo punto situazione

01:02:02se ha un suono o no non lo fa

01:02:04importa perché stiamo chiamando l’animale

01:02:05versione di due archi e l’animale

01:02:08versione di due stringa di stampa solo

01:02:09l’altezza e il peso nonché la

01:02:12nome e poi, infine, si può vedere a destra

01:02:13qui, dove i distruttori sono chiamati

01:02:16e tutti i nostri oggetti vengono distrutti

01:02:18bene ora è il momento di parlare di virtual

01:02:20metodi e polimorfismo sarò hold

01:02:23off la definizione per il polimorfismo

01:02:26qui e invece di creare un nuovo animale

01:02:28classe e sta andando ad avere qualche pubblico

01:02:31roba che fa e quello che sta succedendo

01:02:33da fare qui in primo luogo fuori è ottenere che la famiglia

01:02:36Ho intenzione di fare riferimento a come una famiglia di

01:02:38Oggetti e non solo che siamo

01:02:42animali da vicino quello fuori e quindi questo è

01:02:45dove otteniamo due metodi virtuali sono

01:02:47andando a segnare questa come virtuale e poi

01:02:49Ho intenzione di cambiare di nuovo

01:02:51dal virtuale fondamentalmente vi segnalo un metodo

01:02:53come virtuale quando sappiamo che un animale

01:02:56in questa situazione sarà una classe base

01:02:58che possono avere questo metodo sovrascritti da

01:03:01una sottoclasse e si sta andando a vederlo in

01:03:03azione qui ti farà più senso quando

01:03:04si vede in azione così in questo

01:03:06situazione diciamo classe ottenere e poi

01:03:08Sono andare andando sto e e va bene così questi

01:03:12sono tutti nella famiglia di animali, ma la

01:03:14classe specifica di questo è animale

01:03:17questa situazione e chiudere quello fuori e

01:03:19ora stiamo andando ad avere bisogno di creare un

01:03:20sottoclasse chiamato cane di tipo e di più

01:03:23sta andando a ereditare da animale e

01:03:25sta andando ad avere campo pubblico che

01:03:27eredita tutto ottenere di classe in questo

01:03:30caso io sono un cane sta per essere stampato

01:03:33fuori e poi chiudere quella classe ora

01:03:35quello che stiamo andando a essere in grado di fare qui

01:03:37è sceso all’interno di qui creare un

01:03:39classe animale è equivalente al nuovo animale e

01:03:42cane in questa situazione nuovo cane ora in

01:03:45questa situazione non sta andando alla materia

01:03:47se questo è contrassegnato come virtuale o no

01:03:50perché questi sono entrambi i riferimenti a

01:03:52animali e cani, come si può vedere a destra

01:03:54qui posso solo andare animale – ottenere class

01:03:57e il cane dot ottenere giusta classe del genere

01:04:01qui ho ottenuto la parte virtuale, fuori di lì

01:04:03e qui si può vedere se eseguo questo

01:04:05Sono un cane e io sono un animale sia per la stampa

01:04:07sono sullo schermo se ero comunque

01:04:09andando a cercare e chiamare ottenere classe da un

01:04:12funzione che si sta andando a vedere che otteniamo

01:04:14alcuni problemi in modo Qui stiamo andando a dire

01:04:15vuoto che classe sei e passiamo in

01:04:19un oggetto animale sono entrambi animali

01:04:21oggetti ricordano bene si potrebbe pensare

01:04:22Sarei in grado di andare animale classe get e

01:04:25ottenere i esattamente gli stessi risultati tuttavia

01:04:28come si sta andando a vedere se lo faccio da

01:04:30passando animali e il cane non otteniamo

01:04:33i risultati che si aspettano invece che cosa

01:04:35succede è che io sono un animale viene passato in

01:04:37entrambe le volte, se vogliamo essere in grado di chiamare

01:04:40la corretta classe di ottenere per il cane e il

01:04:43corretta classe di ottenere per l’animale tutto ciò che

01:04:46bisogno di fare è venire qui e digitare

01:04:48virtuale e tutto ciò che significa è che è

01:04:50dicendo hey ci aspettiamo che questo per cambiare in modo

01:04:53se si ottiene un cane che si tratti di un animale

01:04:55o no perché non vai a prendere una possibilità

01:04:56e dare un’occhiata a se risiede classe get

01:04:59nella classe cane o cane

01:05:02e ora si sta andando a vedere tutto

01:05:03stampa esattamente il modo in cui in questo momento

01:05:05stiamo andando a venire e creare un

01:05:06altro paio di classi Diciamo che abbiamo

01:05:08anche voler creare un’altra classe e

01:05:10chiamiamolo questo pastore tedesco che è

01:05:13un po ‘più specifica ed è

01:05:16sta per essere di tipo cane e poi faremo

01:05:19andare in e digitare public void e

01:05:21sovrascrittura ottenere classe con Io sono un tedesco

01:05:25Shepherd Ndele chiusura parentesi graffa e

01:05:28get vuoto derivato sono un animale e cane

01:05:33Ndele chiusura parentesi graffa e ora vengono

01:05:36qui e sperimentare un po ‘

01:05:37più vedere praticamente tutto quello che il polimorfismo

01:05:39mezzi è quando un animale viene passato

01:05:42in questa situazione, come ha fatto proprio qui

01:05:44siamo passati in un oggetto animale è

01:05:48andare automaticamente per trovare il giusto

01:05:50metodo da chiamare in modo che è che è

01:05:52In sostanza è ora Ci sono molti modi voi

01:05:54può applicare il polimorfismo, ma il polimorfismo

01:05:56in base ai propri sguardi del genere quindi cerchiamo di

01:05:58creare un oggetto cane e poi facciamo

01:06:01creare un pastore tedesco e lo chiamano

01:06:04max classe base può anche chiamare derivato

01:06:07metodi di classe fintanto che esistono in

01:06:10la classe base in modo che andremo a venire

01:06:12qui creare un animale è un puntatore a

01:06:15il cane e per ottenere un riferimento da individuare

01:06:17abbiamo appena messo quel piccolo inversa e in

01:06:19non creare un altro e questo il punto

01:06:21il pastore tedesco ottenere un riferimento

01:06:24a quello con Max ora possiamo chiamare il

01:06:27metodo che non è stato sovrascritto da qualsiasi

01:06:30delle altre classi ottengono famiglia che è

01:06:33lo stesso un animale che potremmo anche chiamare

01:06:35ottenere classe che è stato sovrascritto e quindi

01:06:38vieni qui cambiare questo distribuito dispiace

01:06:40di questo e poi, naturalmente, anche vicino

01:06:42fuori la nostra classe la parentesi graffa e

01:06:43eseguirlo e non ci si può vedere che siamo

01:06:46cani siamo stati in grado di chiamare questo ragazzo

01:06:48correttamente e poi ho un cane vedo questo è

01:06:52un riferimento al punto cane e siamo stati in grado

01:06:55chiamare il corretto famiglia get perché

01:06:57questo è stato indicato come un animale e anche

01:07:00siamo in grado di chiamare il molto specifico

01:07:01classe che risiede in cane, anche se

01:07:04questi sono stati indicati come gli animali altro

01:07:06esempio di polimorfismo un’altra cosa

01:07:08che è pulito è in realtà possiamo chiamiamo

01:07:10superclasse pastore tedesco perché

01:07:13tutto è ereditato in modo che possiamo chiamare

01:07:16ottenere famiglia che risiede nella animali

01:07:19di classe e naturalmente possiamo anche chiamare il

01:07:22Versione sovrascritti pastore tedesco

01:07:24pastore e viene automaticamente andando a

01:07:26andare a prendere la cosa giusta, come si può

01:07:28vediamo proprio lì che siamo animali e io sono un

01:07:30Pastore Tedesco quindi c’è un esempio di

01:07:32utilizzando metodi virtuali e nel suo complesso

01:07:34mazzo di diversi esempi su come

01:07:36opere polimorfismo e poi finalmente

01:07:39ottenere il polimorfismo al cento per cento nella vostra

01:07:41testa andiamo a creare un animale

01:07:44oggetto così come un oggetto cane e un gatto

01:07:46oggetto che tutti ereditano dall’animale

01:07:48classe ora l’animale sta per essere un

01:07:52metodo virtuale di nuovo perché stiamo andando

01:07:54per ignorare e che andremo a trattare

01:07:56loro come animali perché sono ricci

01:07:59staffa e diremo l’animale dice

01:08:02ger fondamentalmente andando a fare esattamente fare

01:08:05Assicurati di mettere che la chiusura parentesi graffa

01:08:07in là e poi non stiamo andando a

01:08:08copiare la parte virtuale in questa situazione

01:08:10nel cane qui che andremo a dire che la

01:08:12cane dice trama e poi il gatto dice meow

01:08:17come compito a casa si poteva guardare in come

01:08:20sarebbe in realtà costituire una classe animale

01:08:22una classe capacità che esiste solo

01:08:24essere derivato da in modo da cercare in quella che

01:08:27è il vostro lavoro, perché voi ragazzi ha chiesto

01:08:28per i compiti a casa per tutto il tempo e ora sono

01:08:30andando a saltare anche qui e vi darà

01:08:32un esempio di ciò che un tipo astratto

01:08:34sembra quindi cerchiamo di dire che abbiamo una macchina

01:08:37e questo è più per completionists

01:08:39ragioni di qualsiasi altra cosa che potrebbe venire

01:08:41qui e public int nuovo virtual ottenere

01:08:46ruote insensibili il valore 0 e int virtuale

01:08:50ottenere porte intorpidite e allora si sarebbe in grado di

01:08:54derivare questo venendo qui e

01:08:56la creazione di una nuova classe chiamata Stationwagon

01:08:58ereditare da auto, anche se non lo fa auto

01:09:01Fare qualsiasi cosa staffa di chiusura si muove che fino

01:09:03e poi entrare e definire tutto

01:09:06che abbiamo visto in macchina generica o la

01:09:09auto generico tipo di dato astratto get insensibile

01:09:12ruote come per ruote che come close

01:09:16che fuori ed allora potremmo andare int get

01:09:19porte intorpidite proprio come abbiamo definito qui

01:09:22in questo tipo di dato astratto per la fase auto

01:09:25carro ha quattro porte e allora potremmo

01:09:28anche venire qui e andare station wagon

01:09:30creare un costruttore vuoto e

01:09:33distruttore proprio come quella ora diamo

01:09:35saltare giù nel Maine e giocare con

01:09:37questi ragazzi così stiamo andando a creare

01:09:39un altro animale qui per il nostro gatto e al

01:09:42cosa che chiamiamo semplicemente gatto e animale cane

01:09:44nuovo cane e possiamo vedere che se chiamiamo

01:09:48il gatto specificamente dicendo che vogliamo

01:09:50per fare un suono e poi fare lo stesso

01:09:52cosa con il cane si può vedere che la

01:09:54gatto dice meow e il cane lupo dice anche

01:09:57anche se sono entrambi impostato come animali

01:09:58ora andiamo in e testare i nostri astratto

01:10:00tipo di dati con la macchina Creiamo un

01:10:03auto famigliare

01:10:04di tipo di auto è pari a nuova stazione

01:10:07carro

01:10:07Mi piace questo e anche se è una vettura

01:10:10oggetto ottenere ruote intorpidite si può vedere che

01:10:13station wagon ha quattro ruote rivela

01:10:15lì sullo schermo c’è un intero

01:10:16mazzo di diversi esempi di

01:10:17il polimorfismo e un sacco di

01:10:19informazioni su C ++ speranza voi ragazzi goduto

01:10:22questo video se effettivamente guardare il

01:10:24tutta intera cosa si prega di lasciare un

01:10:25commento mi dice così mi sarebbe davvero

01:10:27apprezzare il fatto che e vi prego di lasciare la vostra

01:10:29domande e commenti di seguito altrimenti

01:10:31fino alla prossima volta