CS50 Library CS50 Afrikaans Kannada

CS50 LibraryYouTube↗ IA↗(long shot)
Education 19.6K views 0 likes 0 dislikes 26 Sep 2012

CS50 2.4M subscribers United States YouTube↗

[Powered by Google Translate] [CS50 Library]

[Powered by Google Translate] [CS50 ಲೈಬ್ರರಿ]

[Nate Hardison] [Harvard Universiteit]

[ನೇಟ್ Hardison] [ಹಾರ್ವರ್ಡ್ ವಿಶ್ವವಿದ್ಯಾಲಯ]

[Hierdie is CS50. CS50.TV]

[ಈ CS50 ಹೊಂದಿದೆ. CS50.TV]

Die CS50 biblioteek is 'n nuttige hulpmiddel wat ons op die toestel geïnstalleer

CS50 ಗ್ರಂಥಾಲಯದ ನಾವು ಉಪಕರಣದಲ್ಲಿ ಅನುಸ್ಥಾಪಿತವಾದ ಒಂದು ಉಪಯುಕ್ತ ಸಾಧನ

te maak dit makliker vir jou programme te kan skryf wat vinnige gebruikers vir insette.

ನೀವು ಪ್ರೋಗ್ರಾಂಗಳನ್ನು ಬರೆಯಲು ಸುಲಭವಾಗುತ್ತದೆ ಎಂದು ಇನ್ಪುಟ್ ಪ್ರಾಂಪ್ಟಿನಲ್ಲಿ ಬಳಕೆದಾರರು.

In hierdie video, sal ons trek die gordyn terug en kyk na wat presies is in die CS50 biblioteek.

ಈ ವಿಡಿಯೋ, ನಾವು ಕೂಡು ಹಿಂತೆಗೆದುಕೊಳ್ಳುವುದನ್ನು ಮಾಡುತ್ತೇವೆ ಮತ್ತು CS50 ಗ್ರಂಥಾಲಯದಲ್ಲಿ ನಿಖರವಾಗಿ ಏನು ನೋಡೋಣ.

>> In die video op die C-biblioteke, ons praat oor hoe jy # headers lêers

>> ಸಿ ಗ್ರಂಥಾಲಯಗಳು ಮೇಲೆ ವಿಡಿಯೋ, ನಾವು ನೀವು # ಹೆಡರ್ ಕಡತಗಳನ್ನು ಒಳಗೊಂಡಿದೆ ಹೇಗೆ ಬಗ್ಗೆ ಮಾತನಾಡಲು

van die biblioteek in jou bronkode,

ನಿಮ್ಮ ಮೂಲ ಕೋಡ್ ಗ್ರಂಥಲಯದ,

en dan het jy 'n skakel met 'n binêre biblioteek lêer tydens die koppeling fase

ತದನಂತರ ನೀವು ಲಿಂಕ್ ಹಂತದಲ್ಲಿ ಅವಳಿ ಗ್ರಂಥಾಲಯದ ಕಡತದಲ್ಲಿ ಲಿಂಕ್

van die samestelling.

ಸಂಕಲನ ಪ್ರಕ್ರಿಯೆಯ.

Met die kopteksbeelde lêers spesifiseer die koppelvlak van die biblioteek.

ಹೆಡರ್ ಕಡತಗಳನ್ನು ಗ್ರಂಥಲಯದ ಇಂಟರ್ಫೇಸ್ ಸೂಚಿಸಿ.

Dit beteken dat hulle detail van al die hulpbronne wat die biblioteek beskikbaar vir jou om te gebruik,

ಎಂದು ಅವರು ವಿವರ ನೀವು ಬಳಸಲು ಗ್ರಂಥಾಲಯದ ಲಭ್ಯವಿರುವ ಸಂಪನ್ಮೂಲಗಳನ್ನು ಹೊಂದಿರುವ ಎಲ್ಲಾ ಹೊಂದಿದೆ

soos funksie verklarings, konstantes, en data tipes.

ಕಾರ್ಯ ಘೋಷಣೆಗಳು, ಸ್ಥಿರ, ಮತ್ತು ಡೇಟಾ ಪ್ರಕಾರಗಳು ನಂತಹ.

Die binêre biblioteek lêer bevat die implementering van die biblioteek,

ಅವಳಿ ಗ್ರಂಥಾಲಯದ ಫೈಲ್, ಗ್ರಂಥಾಲಯದ ಅನುಷ್ಠಾನಕ್ಕೆ ಒಳಗೊಂಡಿದೆ

wat is saamgestel uit die biblioteek se header lêers en die biblioteek se c bron kode lêers.

ಇದು ಗ್ರಂಥಾಲಯದ ಹೆಡರ್ ಕಡತಗಳನ್ನು ಮತ್ತು ಗ್ರಂಥಾಲಯದಲ್ಲಿ. ಸಿ ಮೂಲ ಕೋಡ್ ಕಡತಗಳನ್ನು ಸಂಗ್ರಹಿಸಲಾಗಿದೆ.

>> Die binêre biblioteek lêer is nie baie interessant om te kyk want dit is goed, in binêre.

>> ಅವಳಿ ಗ್ರಂಥಾಲಯದ ಕಡತ ಅದು ಬೈನರಿ ರಲ್ಲಿ, ಅಲ್ಲದೆ, ಅವರ ನಂತರ ನೋಡಲು ಕುತೂಹಲಕಾರಿ ಅಲ್ಲ.

So, kom ons neem 'n blik op die kopteksbeelde lêers vir die biblioteek plaas.

ಆದ್ದರಿಂದ, ಶೀರ್ಷಿಕೆ ಗ್ರಂಥಾಲಯಕ್ಕೆ ಕಡತಗಳನ್ನು ಬದಲಿಗೆ ಅವಲೋಕಿಸೋಣ.

In hierdie geval, daar is net een header lêer genaamd cs50.h.

ಈ ಸಂದರ್ಭದಲ್ಲಿ, cs50.h. ಎಂಬ ಕೇವಲ ಒಂದು ಹೆಡರ್ ಕಡತವನ್ನು ಇಲ್ಲ

Ons het dit in die gebruiker geïnstalleer, sluit directory

ನಾವು ಬಳಕೆದಾರರು ಅನುಸ್ಥಾಪನೆಯ ನೀವು ಕೋಶವನ್ನು ಸೇರಿವೆ

saam met die ander stelsel biblioteke header lêers.

ಇತರ ವ್ಯವಸ್ಥೆಯ ಲೈಬ್ರರಿಗಳನ್ನು 'ಹೆಡರ್ ಕಡತಗಳನ್ನು ಜೊತೆಗೆ.

>> Een van die eerste dinge wat jy sal sien, is dat cs50.h # sluit header lêers van ander biblioteke

>> ನೀವು ಗಮನಿಸಿ ಮೊಟ್ಟ ಮೊದಲ ಕೆಲಸಗಳಲ್ಲಿ ಒಂದು cs50.h # ಇತರ ಲೈಬ್ರರಿಗಳಿಂದ ಹೆಡರ್ ಕಡತಗಳನ್ನು ಯನ್ನು ಹೊಂದಿದೆ -

float, limiete, standaard Bool, en standaard lib.

ಫ್ಲೋಟ್, ಮಿತಿಗಳನ್ನು, ಪ್ರಮಾಣಿತ bool, ಮತ್ತು ಪ್ರಮಾಣಿತ lib.

Weereens, na aanleiding van die beginsel van nie die wiel weer uitvind,

ಮತ್ತೆ, ಚಕ್ರ `ಪುನರ್ ಶೋಧನೆ ಇಲ್ಲ ತತ್ವ ಅನುಸರಿಸಿ,

ons het die CS0 biblioteek met behulp van gereedskap wat ander vir ons gebou.

ನಾವು ಇತರ ನಮಗೆ ಒದಗಿಸಿದ ಉಪಕರಣಗಳು ಬಳಸಿಕೊಂಡು CS0 ಗ್ರಂಥಾಲಯ ನಿರ್ಮಾಣ ಮಾಡಿದ.

>> Die volgende ding wat jy sien in die biblioteek is dat ons 'n nuwe soort sogenaamde "string definieer."

>> ನೀವು ಗ್ರಂಥಾಲಯದಲ್ಲಿ ನೋಡುತ್ತಾರೆ ಮುಂದೆ ನಾವು ಎಂಬ ಹೊಸ ರೀತಿಯ ವ್ಯಾಖ್ಯಾನ ಎಂದು "ಸ್ಟ್ರಿಂಗ್."

Hierdie reël skep eintlik maar net 'n alias vir die tipe char *

ಈ ಲೈನ್ ನಿಜವಾಗಿಯೂ ಕೇವಲ ಚಾರ್ * ರೀತಿಯ ಅಲಿಯಾಸ್ ಸೃಷ್ಟಿಸುತ್ತದೆ,

sodat dit mettertyd nie kant die nuwe string tipe met eienskappe

ಆದ್ದರಿಂದ ಮಾಂತ್ರಿಕವಾಗಿ ಲಕ್ಷಣಗಳು ಹೊಸ ಸ್ಟ್ರಿಂಗ್ ರೀತಿಯ imbue ಇಲ್ಲ

algemeen geassosieer met die string voorwerpe in ander tale,

ಸಾಮಾನ್ಯವಾಗಿ ಇತರ ಭಾಷೆಗಳಲ್ಲಿ ಸ್ಟ್ರಿಂಗ್ ವಸ್ತುಗಳ ಸಂಬಂಧಿತ

soos lengte.

ಉದಾಹರಣೆಗೆ ಉದ್ದ.

Die rede waarom ons dit gedoen het, is om nuwe programmeerders te beskerm teen die gruwelike besonderhede

ನಾವು ಮಾಡಿದ ಕಾರಣಕ್ಕಾಗಿ ರಕ್ತಸಿಕ್ತ ವಿವರಗಳನ್ನು ಹೊಸ ಪ್ರೋಗ್ರಾಮರ್ಗಳು ರಕ್ಷಿಸಲು ಆಗಿದೆ

wysers totdat hulle klaar is.

ಪಾಯಿಂಟರ್ಗಳ ಅವರು ಸಿದ್ಧರಾಗಿರುವಾಗ ರವರೆಗೆ.

>> Die volgende deel van die header-lêer is die verklaring van die funksies

>> ಹೆಡರ್ ಕಡತವನ್ನು ಮುಂದಿನ ಭಾಗವಾಗಿ ಕಾರ್ಯಗಳನ್ನು ಘೋಷಣೆಯಾಗಿದೆ

dat die CS50 biblioteek verskaf saam met die dokumentasie.

CS50 ಗ್ರಂಥಾಲಯದ ದಸ್ತಾವೇಜನ್ನು ಜೊತೆಗೆ ಒದಗಿಸುತ್ತದೆ.

Let op die vlak van detail in die kommentaar hier.

ಇಲ್ಲಿ ಕಾಮೆಂಟ್ಗಳನ್ನು ವಿವರವಾಗಿ ಮಟ್ಟವನ್ನು ಗಮನಿಸಿ.

Dit is super belangrik sodat mense weet hoe om hierdie funksies te gebruik.

ಜನರು ಈ ಕಾರ್ಯಗಳನ್ನು ಬಳಸಲು ಗೊತ್ತಿಲ್ಲ ಆದ್ದರಿಂದ ಈ ಪ್ರಮುಖ ಸೂಪರ್ ಆಗಿದೆ.

Ons verklaar, op sy beurt, funksioneer die gebruiker en terugkeer karakters, dubbels, dryf, ints aan te spoor,

ನಾವು ಪ್ರತಿಯಾಗಿ, ಘೋಷಿಸಲು, ಬಳಕೆದಾರ ಮತ್ತು ರಿಟರ್ನ್ ಅಕ್ಷರಗಳನ್ನು, ಡಬಲ್ಸ್, ಫ್ಲೋಟ್ಗಳು, ints, ಪ್ರಾಂಪ್ಟ್ ಮಾಡಲು ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ

lank verlang, en snare, met behulp van ons eie string tipe.

ದೀರ್ಘ ದೂರವುಳಿಯಬೇಕಾಗುತ್ತದೆ, ಮತ್ತು ತಂತಿಗಳು ನಮ್ಮ ಸ್ಟ್ರಿಂಗ್ ರೀತಿಯ ಬಳಸಿ.

Na aanleiding van die beginsel van inligting wegkruip,

ಇನ್ಫರ್ಮೇಷನ್ ಹೈಡಿಂಗ್ ತತ್ವ ಅನುಸರಿಸಿ,

ons het ons definisie in 'n aparte c implementering lêer - cs50.c -

. ನಾವು ಪ್ರತ್ಯೇಕ ಸಿ ಅನುಷ್ಠಾನ ಕಡತದಲ್ಲಿ ನಮ್ಮ ವ್ಯಾಖ್ಯಾನ ಹಾಕಬಹುದು - cs50.c--

geleë in die gebruiker bron gids.

ಬಳಕೆದಾರ ಮೂಲ ಕೋಶದಲ್ಲಿ ಇದೆ.

Ons het voorsien dat die lêer sodat jy kan 'n blik op dit,

ನೀವು ಒಂದು ನೋಟ ತೆಗೆದುಕೊಳ್ಳಬಹುದು ಆದ್ದರಿಂದ ನಾವು ಆ ಕಡತ ಒದಗಿಸಲಾದ

leer uit dit, en heropstel dit op verskillende masjiene as jy wil,

ಅದರಿಂದ ತಿಳಿಯಲು, ಮತ್ತು ನೀವು ಬಯಸಿದರೆ ವಿವಿಧ ಗಣಕಗಳಲ್ಲಿ ಇದು ಮರುಸಂಕಲಿಕೆಯು,

selfs al het ons dink dit is beter om te werk op die toestel vir hierdie klas.

ನಾವು ಈ ವರ್ಗದ APPLIANCE ಕೆಲಸ ಮಾಡಲು ಉತ್ತಮ ಭಾವಿಸುತ್ತೇನೆ ಸಹ.

In elk geval, laat ons neem 'n blik op dit nou.

ಹೇಗಾದರೂ, ಈಗ ಅದು ಒಂದು ಅವಲೋಕಿಸೋಣ.

>> Die funksies getChar, GetDouble, GetFloat, getint, en GetLongLong

>> ಕಾರ್ಯಗಳನ್ನು GetChar, GetDouble, GetFloat, GetInt, ಮತ್ತು GetLongLong

is almal gebou op die top van die GetString funksie.

ಎಲ್ಲಾ GetString ಕ್ರಿಯೆಯ ಮೇಲೆ ನಿರ್ಮಿಸಲಾಗಿದೆ.

Dit blyk dat hulle in wese almal volg dieselfde patroon.

ಅವರು ಎಲ್ಲಾ ಅದೇ ಮಾದರಿಯನ್ನು ಅನುಸರಿಸುತ್ತವೆ ಎಂಬುದನ್ನು ತಿರುಗುತ್ತದೆ.

Hulle maak gebruik van 'n while lus om die gebruiker vir 'n lyn van die toevoer te vinnig.

ಅವರು ಇನ್ಪುಟ್ ಒಂದು ಸಾಲಿನ ಬಳಕೆದಾರ ಮಾಡುವಂತೆ ಸ್ವಲ್ಪ ಲೂಪ್ ಅನ್ನು.

Hulle terugkeer 'n spesiale waarde indien die gebruiker 'n leë lyn insette.

ಅವರು ಯೂಸರ್ ಇನ್ಪುಟ್ಸ್ ಖಾಲಿ ಸಾಲು ವೇಳೆ ವಿಶೇಷ ಮೌಲ್ಯವನ್ನು ಹಿಂತಿರುಗಿಸಬೇಕು.

Hulle probeer om die gebruiker se insette te ontleed as die toepaslike tipe,

ಅವರು, ಸೂಕ್ತ ರೀತಿಯ ಬಳಕೆದಾರರ ಇನ್ಪುಟ್ ಪಾರ್ಸ್ ಪ್ರಯತ್ನ

word dit 'n char, 'n dubbel, 'n float, ens.

ಅದು ಅಕ್ಷರ, ಎರಡು, ಒಂದು ಫ್ಲೋಟ್, ಇತ್ಯಾದಿ ಎಂದು

En dan sal hulle die resultaat terug indien die inset is suksesvol ontleed

ಇನ್ಪುಟ್ ಯಶಸ್ವಿಯಾಗಿ ಪಾರ್ಸ್ ಎಂದು ಅವನ್ನು ಎರಡೂ ಪರಿಣಾಮವಾಗಿ ಹಿಂತಿರುಗಿ

of hulle reprompt die gebruiker.

ಅಥವಾ ಬಳಕೆದಾರ reprompt.

>> Op 'n hoë vlak, is daar niks regtig lastig hier.

>> ಒಂದು ಉನ್ನತ ಮಟ್ಟದಲ್ಲಿ, ನಿಜವಾಗಿಯೂ ಟ್ರಿಕಿ ಏನೂ ಇಲ್ಲಿ ಇಲ್ಲ.

Jy kan insgelyks gestruktureerde kode geskryf het jouself in die verlede.

ನೀವು ಹಿಂದೆ ಇದೇ ರಚನಾತ್ಮಕ ಕೋಡ್ ನೀವೇ ಬರೆದಿದ್ದಾರೆ ಇರಬಹುದು.

Miskien is die mees kriptiese-looking deel is die sscanf oproep wat die gebruiker se insette ontleed.

ಬಹುಶಃ ಅತ್ಯಂತ ರಹಸ್ಯ ಕಾಣುವ ಭಾಗ ಬಳಕೆದಾರರ ಇನ್ಪುಟ್ parses ಎಂದು sscanf ಕರೆಯಾಗಿದೆ.

Sscanf is deel van die inset-formaat omskakeling familie.

Sscanf ಇನ್ಪುಟ್ ರೂಪದಲ್ಲಿ ಪರಿವರ್ತನೆ ಕುಟುಂಬದ ಭಾಗವಾಗಿದೆ.

Dit leef in standaard io.h, en sy werk is 'n C-string te ontleed,

, ಅದು ಪ್ರಮಾಣಿತ io.h ವಾಸಿಸುತ್ತಾರೆ, ಮತ್ತು ಅದರ ಕೆಲಸ ಒಂದು ಸಿ ಸ್ಟ್ರಿಂಗ್ ಪರ್ಸ್ ಮಾಡುವ

volgens 'n spesifieke formaat, die stoor van die parse uitslae in veranderlike

ವೇರಿಯಬಲ್ ಅನ್ನು ಫಲಿತಾಂಶಗಳನ್ನು ಸಂಗ್ರಹಿಸುವ, ಒಂದು ನಿರ್ದಿಷ್ಟ ಸ್ವರೂಪ ಪ್ರಕಾರ

wat deur die oproeper.

ಕಾಲರ್ ಒದಗಿಸಿದ.

Sedert die invoer formaat omskakeling funksies is baie nuttig, wyd gebruik word funksies

ಇನ್ಪುಟ್ ರೂಪದಲ್ಲಿ ಪರಿವರ್ತನೆ ಕಾರ್ಯಗಳನ್ನು ತುಂಬಾ ಉಪಯುಕ್ತ, ವ್ಯಾಪಕವಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ ಕಾರ್ಯಗಳನ್ನು ಕಾರಣ

wat nie super intuïtief op die eerste,

, ಮೊದಲು ಅಂತರ್ಬೋಧೆಯ ಸೂಪರ್ ಎಂದು

ons gaan oor hoe sscanf werk.

ನಾವು sscanf ಕೆಲಸ ಹೇಗೆ ಮೇಲೆ ಹೋಗುತ್ತೇನೆ.

>> Die eerste argument te sscanf is 'n char * - 'n wyser na 'n karakter.

>> sscanf ಮೊದಲ ವಾದವನ್ನು ಒಂದು ಚಾರ್ * ಹೊಂದಿದೆ - ಒಂದು ಅಕ್ಷರಕ್ಕೆ ಒಂದು ಪಾಯಿಂಟರ್.

Vir die funksie om behoorlik te werk,

ಕಾರ್ಯವನ್ನು ಸರಿಯಾಗಿ ಕೆಲಸ ಮಾಡಲು

dat die karakter moet die eerste teken van 'n C-string,

ಆ ಪಾತ್ರ, ಒಂದು ಸಿ ಸ್ಟ್ರಿಂಗ್ ಮೊದಲ ಅಕ್ಷರ ಆಗಿರಬೇಕು

beëindig met die null \ 0 karakter.

ಶೂನ್ಯ \ 0 ಅಕ್ಷರದೊಂದಿಗೆ ಅಂತ್ಯಗೊಳ್ಳುತ್ತದೆ.

Dit is die string te ontleed

ಈ ಪಾರ್ಸ್ ಸರಣಿಯನ್ನು ಹೊಂದಿದೆ

Die tweede argument te sscanf is 'n formaat string,

sscanf ಎರಡನೇ ವಾದ, ಒಂದು ಸ್ವರೂಪ ಸ್ಟ್ರಿಂಗ್ ಆಗಿದೆ

tipies as 'n string konstante geslaag,

ವಿಶಿಷ್ಟವಾಗಿ, ಒಂದು ಸ್ಟ್ರಿಂಗ್ ಸ್ಥಿರ ರಲ್ಲಿ ಜಾರಿಗೆ

en jy mag gesien het 'n string soos hierdie voor wanneer die gebruik van printf.

ಮತ್ತು ನೀವು printf ಬಳಸುವಾಗ ಮೊದಲು ಈ ರೀತಿಯ ಒಂದು ಸ್ಟ್ರಿಂಗ್ ನೋಡಿರಬಹುದು.

'N%-teken in die formaat string dui op 'n omskakeling specific.

ಸ್ವರೂಪ ಸ್ಟ್ರಿಂಗ್ ಒಂದು ಶೇಕಡಾ ಚಿಹ್ನೆ ಒಂದು ಪರಿವರ್ತನೆ ನಿಷ್ಕೃಷ್ಟ ವಿವರಣೆ ಸೂಚಿಸುತ್ತದೆ.

Die karakter wat onmiddellik volg op 'n persentasie teken,

ಅಕ್ಷರ ತಕ್ಷಣ, ಒಂದು ಪ್ರತಿಶತ ಸೈನ್ ನಂತರ

dui op die C-tipe wat ons wil sscanf te omskep.

ನಾವು ಮತಾಂತರಗೊಳ್ಳಲು sscanf ಬಯಸುವ ಸಿ ಪ್ರಕಾರವನ್ನು ಸೂಚಿಸುತ್ತದೆ.

In getint, sien jy dat daar is 'n% d en% c.

GetInt, ನೀವು ಒಂದು% s ಮತ್ತು% ಸಿ ಎಂದು ನೋಡಿ.

Dit beteken dat sscanf sal probeer om 'n desimale int -% d - en 'n char -% c.

% D - - ಮತ್ತು ಚಾರ್ -% ಸಿ ಈ sscanf ಒಂದು ದಶಮಾಂಶ ಇಂಟ್ ಪ್ರಯತ್ನಿಸುತ್ತೇವೆ ಎಂದರ್ಥ.

Vir elke omskakeling specificatie in die formaat string,

ಫಾರ್ಮ್ಯಾಟ್ ಸಾಲಿನಲ್ಲಿ ಪ್ರತಿ ಪರಿವರ್ತನೆ ನಿಷ್ಕೃಷ್ಟ ವಿವರಣೆ ಗೆ,

sscanf verwag dat 'n ooreenstemmende argument later in sy argument lys.

sscanf ತನ್ನ ವಾದವನ್ನು ಪಟ್ಟಿಯಲ್ಲಿ ಅನುಗುಣವಾದ ವಾದದ ನಂತರ ನಿರೀಕ್ಷಿಸುತ್ತದೆ.

Daardie argument moet verwys na 'n toepaslik getikte plek

ಎಂಬ ವಾದವನ್ನು ಒಂದು ಸೂಕ್ತವಾಗಿ ಟೈಪ್ ಸ್ಥಳ ಬೆಟ್ಟು ಮಾಡಬೇಕು

wat die gevolg van die omskakeling te stoor.

ಪರಿವರ್ತನೆ ಫಲಿತಾಂಶವನ್ನು ಶೇಖರಿಸಿಡಲು ಇದರಲ್ಲಿ.

>> Die tipiese manier om dit te doen is om 'n veranderlike te skep op die stapel voor die sscanf oproep

>> ಈ ಮಾಡುವ ವಿಶಿಷ್ಟ ರೀತಿಯಲ್ಲಿ sscanf ಕರೆ ಮೊದಲು ಸ್ಟಾಕ್ ಮೇಲೆ ವೇರಿಯಬಲ್ ರಚಿಸುವುದು

vir elke item wat jy wil om uit die string te parse

ನೀವು ದಾರದಿಂದ ಪಾರ್ಸ್ ಬಯಸುವ ಪ್ರತಿ ಐಟಂಗೆ

en gebruik dan die adres operateur - die ampersand - wysers te slaag

ಪಾಯಿಂಟರ್ಸ್ ರವಾನಿಸಲು - ವನ್ನಾಗಲಿ - ತದನಂತರ ವಿಳಾಸಕ್ಕೆ ಆಯೋಜಕರು ಬಳಸಿ

aan daardie veranderlikes aan die sscanf oproep.

sscanf ಕರೆ ಆ ಏರುಪೇರುಗಳಲ್ಲಿ.

Kan jy sien dat in getint ons presies dit doen.

ನೀವು GetInt ನಾವು ನಿಖರವಾಗಿ ಇದನ್ನು ಕಾಣಬಹುದು.

Reg voor die sscanf oproep, verklaar ons 'n int n en 'n char oproep c op die stapel,

ಬಲ sscanf ಕರೆ ಮೊದಲು, ನಾವು, n ಎಂಬ ಒಂದು ಇಂಟ್ ಮತ್ತು ಸ್ಟಾಕ್ ಮೇಲೆ ಚಾರ್ ಕರೆ ಸಿ ಘೋಷಿಸಲು

en ons verwysings na hulle slaag in die sscanf oproep.

ಮತ್ತು ನಾವು sscanf ಕರೆ ಅವುಗಳನ್ನು ರೀತಿಯು ಹಾದುಹೋಗುತ್ತವೆ.

Om hierdie veranderlikes op die stapel word verkies bo die gebruik van spasie

ಸ್ಟಾಕ್ ಈ ಅಸ್ಥಿರಗಳು ಪುಟ್ಟಿಂಗ್ ನಿಯೋಜಿತವಾದ ಸ್ಥಳವನ್ನು ಬಳಸಿಕೊಂಡು ಹೆಚ್ಚು ಆದ್ಯತೆ

op die hoop met malloc, omdat jy die oorhoofse van die malloc oproep te vermy,

ನೀವು malloc ಕರೆಯ ಓವರ್ಹೆಡ್ ತಪ್ಪಿಸಲು ರಿಂದ malloc ಹೊಂದಿರುವ ರಾಶಿ, ಮೇಲೆ,

en jy hoef nie te bekommer oor die lek van geheue.

ಮತ್ತು ನೀವು ಮೆಮೊರಿ ಸೋರಿಕೆ ಬಗ್ಗೆ ಚಿಂತೆ ಇಲ್ಲ.

Karakters word nie voorafgegaan deur 'n persentasie teken gevra nie bekering.

ಒಂದು ಪ್ರತಿಶತ ಸೈನ್ ಅದಕ್ಕೆ ಪೂರ್ವಪ್ರತ್ಯಯವನ್ನು ಅಕ್ಷರಗಳು ಪರಿವರ್ತನೆ ಮಾಡುವಂತೆ ಇಲ್ಲ.

Eerder hulle voeg net na die formaat spesifikasie.

ಬದಲಿಗೆ ಅವರು ಸ್ವರೂಪದ ವಿಶಿಷ್ಟ ಸೇರಿಸಲು.

>> Byvoorbeeld, as die formaat string in getint was 'n% d in plaas daarvan,

>> ಉದಾಹರಣೆಗೆ, GetInt ಸ್ವರೂಪದಲ್ಲಿ ಸ್ಟ್ರಿಂಗ್ ಬದಲಿಗೆ% s ಆಗಿದ್ದರೆ,

sscanf sal kyk vir die letter A, gevolg deur 'n int,

sscanf, ಒಂದು int ನಂತರ ಪತ್ರವನ್ನು ನೋಡಿ ಎಂದು

en terwyl dit poog om die int te omskep, sou dit nie doen nie enigiets anders met die a.

ಇದು ಇಂಟ್ ಪರಿವರ್ತಿಸಲು ಪ್ರಯತ್ನಿಸುವುದಾಗಿ ಸಂದರ್ಭದಲ್ಲೇ ಇದು ಒಂದು ಜೊತೆ ಬೇರೆ ಏನನ್ನೂ ಮಾಡುವುದಿಲ್ಲ.

Die enigste uitsondering op hierdie spasie.

ಈ ಮಾತ್ರ ಹೊರತುಪಡಿಸಿ ಜಾಗಗಳನ್ನು ಹೊಂದಿದೆ.

Wit spasie karakters in die formaat string ooreenstem met enige bedrag van spasie -

ಸ್ವರೂಪ ಸ್ಟ್ರಿಂಗ್ ವೈಟ್ ಜಾಗದ ಅಕ್ಷರಗಳನ್ನು ಜಾಗಗಳನ್ನು ಯಾವುದೇ ಪ್ರಮಾಣವನ್ನು ಹೊಂದಿಸಲು -

selfs glad nie.

ಎಲ್ಲಾ ನಲ್ಲಿಯೂ ಯಾವುದೇ.

So, wat is die rede waarom die kommentaar noem moontlik met die leiding en / of eindig met spasies.

ಕಾಮೆಂಟ್ ಪ್ರಮುಖ ಮತ್ತು / ಅಥವಾ ಜಾಗಗಳನ್ನು ಹಿಂದುಳಿದಿದ್ದರು ಜೊತೆ ಪ್ರಾಯಶಃ ಉಲ್ಲೇಖಿಸುತ್ತಾನೆ ಏಕೆ, ಇದು.

So, op hierdie punt is dit lyk soos ons sscanf oproep probeer om die gebruiker se inset string te ontleed

ಆದ್ದರಿಂದ, ನಮ್ಮ sscanf ಕರೆ ತೋರುತ್ತಿದೆ ಈ ಹಂತದಲ್ಲಿ ಬಳಕೆದಾರರ ಇನ್ಪುಟ್ ವಾಕ್ಯವನ್ನು ಪಾರ್ಸ್ ಮಾಡಲು ಪ್ರಯತ್ನಿಸಿ

deur te kyk vir moontlike Witruimte,

ಸಂಭಾವ್ಯ ಪ್ರಮುಖ ಜಾಗಗಳನ್ನು ಪರಿಶೀಲಿಸುತ್ತಿದೆ ಮೂಲಕ,

gevolg deur 'n int wat sal omgeskakel word en gestoor in die int veranderlike n

ಇಂಟ್ ವೇರಿಯಬಲ್ N ಪರಿವರ್ತನೆಯಾಗುತ್ತದೆ ಮತ್ತು ಸಂಗ್ರಹಿಸಲಾಗಿದೆ ಒಂದು ಇಂಟ್ ನಂತರ

gevolg deur 'n bedrag van spasie, en gevolg deur 'n karakter

ಜಾಗಗಳನ್ನು ಸ್ವಲ್ಪ ನಂತರ, ಮತ್ತು ಒಂದು ಪಾತ್ರದ ನಂತರ

gestoor in die char veranderlike c.

ಚಾರ್ ವೇರಿಯಬಲ್ ಸಿ ಸಂಗ್ರಹಿಸಲಾಗಿದೆ.

>> Wat oor die terugkeer waarde?

>> ಮರಳುವ ಮೌಲ್ಯವನ್ನು ಏನು?

Sscanf sal die inset lyn parse van begin tot einde,

Sscanf, ಪೂರ್ಣಗೊಳಿಸಲು ಪ್ರಾರಂಭದಿಂದ ಆದಾನ ಸಾಲಿನಲ್ಲಿ ಪಾರ್ಸ್ ಕಾಣಿಸುತ್ತದೆ

stop wanneer dit die einde bereik of wanneer 'n karakter in die inset

ಆದಾನ ಒಂದು ಗುಣವು ತುದಿಯನ್ನು ತಲುಪಿದಾಗ ನಿಲ್ಲಿಸುವ ಅಥವಾ

kom nie ooreen met 'n formaat karakter of wanneer dit nie 'n sukses nie.

ಒಂದು ರೂಪದಲ್ಲಿ ಪಾತ್ರ ಹೊಂದಿಕೆಯಾಗುವುದಿಲ್ಲ ಅಥವಾ ಒಂದು ಪರಿವರ್ತನೆ ಮಾಡಲು ಸಾಧ್ಯವಿಲ್ಲ ಮಾಡಿದಾಗ.

Dit se terugkeer waarde word gebruik om uitsonder wanneer dit opgehou.

ಅದನ್ನು ಮರಳಿ ಮೌಲ್ಯವನ್ನು ನಿಲ್ಲಿಸಿದಾಗಿನಿಂದ ಪ್ರತ್ಯೇಕವಾದಿ ಬಳಸಲಾಗುತ್ತದೆ.

As dit gestop het, omdat dit die einde van die inset string bereik

ಇದು ಇನ್ಪುಟ್ ಸ್ಟ್ರಿಂಗ್ ಕೊನೆಯನ್ನು ತಲುಪಿದ ಕಾರಣ, ನಿಲ್ಲಿಸಿದ ವೇಳೆ

voordat hy enige doelskoppe en voor nie deel van die formaat string aan te pas,

ಯಾವುದೇ ಪರಿವರ್ತನೆಗಳು ಮುನ್ನ ಮತ್ತು ಸ್ವರೂಪ ಸ್ಟ್ರಿಂಗ್ ಭಾಗವಾಗಿ ಹೊಂದಿಸಲು ವಿಫಲಗೊಳ್ಳುವ ಮುಂಚೆ ಮೊದಲಿಗೆ,

dan die spesiale konstante EOF teruggestuur word.

ನಂತರ ವಿಶೇಷ ಸ್ಥಿರ EOF ಮರಳಿ.

Andersins, dit gee die aantal suksesvolle conversies,

ಇಲ್ಲವಾದರೆ, ಅದು ಯಶಸ್ವಿ ಮಾರ್ಪಾಡುಗಳ ಸಂಖ್ಯೆಯಿಂದ ಹಿಂದಿರುಗಿಸುತ್ತದೆ

wat kan wees 0, 1 of 2, aangesien ons het gevra vir twee doelskoppe.

ನಾವು ಎರಡು ಪರಿವರ್ತನೆಗಾಗಿ ಕೇಳಿದ್ದೀರಿ ಏಕೆಂದರೆ ಇದು, 0, 1, ಅಥವಾ 2 ಎಂದು.

In ons geval, ons wil om seker te maak dat die gebruiker in 'n int en slegs 'n int getik.

ನಮ್ಮ ವಿಷಯದಲ್ಲಿ, ನಾವು ಬಳಕೆದಾರರು ಇಂಟ್ ಮತ್ತು ಕೇವಲ ಒಂದು ಇಂಟ್ ಬೆರಳಚ್ಚಿಸಿದ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ ಬಯಸುತ್ತೇನೆ.

>> So, ons wil sscanf 1 om terug te keer. Sien waarom?

>> ಆದ್ದರಿಂದ, ನಾವು sscanf 1 ಮರಳಲು ಬಯಸುವ. ಏಕೆ ನೋಡಿ?

As sscanf teruggekeer 0, dan is geen bekerings gemaak is,

Sscanf 0 ಮರಳಿದರು, ನಂತರ ಯಾವುದೇ ಪರಿವರ್ತನೆಗಳು ಮಾಡಲಾಯಿತು,

sodat die gebruiker ingetik iets anders as 'n int aan die begin van die insette.

ಆದ್ದರಿಂದ ಬಳಕೆದಾರ ಇನ್ಪುಟ್ ಆರಂಭದಲ್ಲಿ ಇಂಟ್ ಬೇರೆಯಾಗಿರುತ್ತದೆ ಟೈಪಿಸಿದ.

As sscanf terugkeer 2, dan is die gebruiker het behoorlik tik dit in aan die begin van die insette,

Sscanf 2 ಹಿಂದಿರುಗಿಸುತ್ತದೆ ವೇಳೆ, ನಂತರ ಬಳಕೆದಾರರು ಸರಿಯಾಗಿ, ಇನ್ಪುಟ್ ಆರಂಭದಲ್ಲಿ ಅದನ್ನು ಟೈಪ್ ಮಾಡಲಿಲ್ಲ

maar hulle dan in sommige nie-spasie karakter getik daarna

ಆದರೆ ಅವರು ನಂತರ ಕೆಲವು ಅಲ್ಲದ ಜಾಗಗಳನ್ನು ಪಾತ್ರ ಬೆರಳಚ್ಚಿಸಿದ

sedert die% c sukses daarin geslaag.

% ರಿಂದ C ಪರಿವರ್ತನೆ ಯಶಸ್ವಿಯಾದರು.

Sjoe, dit is nogal 'n lang verduideliking vir een funksie oproep.

ವಾಹ್, ಎಂದು ಸ್ವಲ್ಪ ಒಂದು ಫಂಕ್ಷನ್ ಕರೆಗೆ ಸುದೀರ್ಘ ವಿವರಣೆ ಇಲ್ಲಿದೆ.

In elk geval, as jy meer inligting wil hê op sscanf en sy broers en susters,

ಹೇಗಾದರೂ, ನೀವು sscanf ಮತ್ತು ಅದರ ಸಿಬ್ಲಿಂಗ್ ಹೆಚ್ಚಿನ ಮಾಹಿತಿ ಬೇಕಾದರೆ,

check die man bladsye, Google, of albei.

ಮನುಷ್ಯ ಪುಟಗಳು, ಗೂಗಲ್, ಅಥವಾ ಎರಡೂ ಪರಿಶೀಲಿಸಿ.

Daar is baie van die formaat string opsies,

ಸ್ವರೂಪ ಸ್ಟ್ರಿಂಗ್ ಆಯ್ಕೆಗಳನ್ನು ಸಾಕಷ್ಟು ಇವೆ

en dit kan red jy 'n baie van die handewerker wanneer ek probeer om stringe te ontleed in C.

ಸಿ ರಲ್ಲಿ ತಂತಿಗಳನ್ನು ಪಾರ್ಸ್ ಪ್ರಯತ್ನಿಸುತ್ತಿರುವಾಗ ಮತ್ತು ಈ ಹಸ್ತಚಾಲಿತ ಕಾರ್ಮಿಕ ಸಾಕಷ್ಟು ಉಳಿಸಬಹುದು

>> Die finale funksie in die biblioteek om na te kyk, is GetString.

>> ನೋಡಲು ಗ್ರಂಥಾಲಯದ ಅಂತಿಮ ಕ್ರಿಯೆ GetString ಹೊಂದಿದೆ.

Dit blyk dat GetString is 'n moeilike funksie behoorlik te skryf,

ಇದು GetString ಸರಿಯಾಗಿ ಬರೆಯಲು ಟ್ರಿಕಿ ಕ್ರಿಯೆಯಾಗಿದೆ ಎಂದು ತಿರುಗುತ್ತದೆ

selfs al is dit lyk asof so 'n eenvoudige, gemeenskaplike taak.

ಅದು ಒಂದು ಸರಳ, ಸಾಮಾನ್ಯ ಕೆಲಸವನ್ನು ಹಾಗೆ ತೋರುತ್ತದೆ ಸಹ.

Hoekom is dit die geval?

ಏಕೆ ಈ ಸಂದರ್ಭದಲ್ಲಿ?

Wel, laat ons dink oor hoe ons hier gaan om die lyn op te slaan dat die gebruiker tipes.

ಅಲ್ಲದೆ, ನ ಹೇಗೆ ನಾವು ಲೈನ್ ಶೇಖರಿಸಿಡಲು ನೀನು ಬಗ್ಗೆ ಯೋಚನೆ ಮಾಡಲು ಸೈನ್ ಬಳಕೆದಾರ ವಿಧಗಳು

Aangesien 'n string is 'n volgorde van die karakters,

ಸ್ಟ್ರಿಂಗ್ ಅಕ್ಷರಗಳನ್ನು ಒಂದು ಅನುಕ್ರಮದ, ಏಕೆಂದರೆ

ons dalk wil om dit te stoor in 'n skikking op die stapel,

ನಾವು, ಸ್ಟಾಕ್ ಮೇಲೆ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಇದು ಶೇಖರಿಸಿಡಲು ಬಯಸಬಹುದು

maar ons sou nodig het om te weet hoe lank die skikking gaan wees wanneer ons dit verklaar.

ಆದರೆ ನಾವು ಅದನ್ನು ಘೋಷಿಸಬಹುದು ಮಾಡಿದಾಗ ವ್ಯೂಹ ಎಂದು ಹೋಗುತ್ತದೆ ಎಷ್ಟು ತಿಳಿಯಲು ಅಗತ್ಯವಿದೆ.

Net so, as ons wil om dit te sit op die wal,

ಹಾಗೆಯೇ, ನಾವು ರಾಶಿ ಮೇಲೆ ಹಾಕಲು ಬಯಸಿದಲ್ಲಿ,

ons nodig het om te slaag malloc die aantal grepe wat ons wil reserwe,

ನಾವು, malloc ನಾವು ಮೀಸಲು ಬಯಸುವ ಬೈಟ್ಗಳು ಸಂಖ್ಯೆಯನ್ನು ಪಾಸ್ ಅಗತ್ಯವಿದೆ

maar dit is onmoontlik.

ಆದರೆ ಈ ಅಸಾಧ್ಯ.

Ons het geen idee hoeveel karakters sal die gebruiker tik

ನಾವು ಬಳಕೆದಾರರು ಟೈಪ್ ಎಷ್ಟು ಅಕ್ಷರಗಳನ್ನು ಕಲ್ಪನೆಯೂ ಇಲ್ಲ

voor die aangesig van die gebruiker tik hulle eintlik nie.

ಬಳಕೆದಾರ ನಿಜವಾಗಿಯೂ ಟೈಪ್ ಮೊದಲು.

>> 'N naïef oplossing vir hierdie probleem is om net te behou 'n groot stuk van die ruimte, sê,

>> ಈ ಸಮಸ್ಯೆಗೆ ಸರಳ ಪರಿಹಾರ ಕೇವಲ, ಜಾಗವನ್ನು ದೊಡ್ಡ ಚಂಕ್ ಕಾಯ್ದಿರಿಸಬೇಕು ಹೇಳುತ್ತಾರೆ, ಆಗಿದೆ

'n blok van 1000 karakters vir die gebruiker se insette,

ಬಳಕೆದಾರರ ಸೇರಿಸುವ 1000 ಅಕ್ಷರಗಳನ್ನು ಒಂದು ಬ್ಲಾಕ್,

die veronderstelling dat die gebruiker nooit sou tik in 'n string wat lank.

ಬಳಕೆದಾರ ದೀರ್ಘ ಸ್ಟ್ರಿಂಗ್ ಟೈಪ್ ಎಂದಿಗೂ ಎಂದು ಊಹಿಸಿ.

Dit is 'n slegte idee om twee redes.

ಈ ಎರಡು ಕಾರಣಗಳಿಗಾಗಿ ಒಂದು ಕೆಟ್ಟ ಕಲ್ಪನೆ.

Eerstens, in die veronderstelling dat gebruikers tipies tik nie in stringe dat die lang,

ಮೊದಲು, ಬಳಕೆದಾರರು ಸಾಮಾನ್ಯವಾಗಿ ದೀರ್ಘ ತಂತಿಗಳನ್ನು ಟೈಪ್ ಎಂದು ಊಹಿಸಿಕೊಂಡು

jy kan mors nie 'n baie van die geheue.

ನೀವು ಮೆಮೊರಿ ಸಾಕಷ್ಟು ತ್ಯಾಜ್ಯವನ್ನು ಸಾಧ್ಯವಾಗಲಿಲ್ಲ.

Op die moderne masjiene, kan dit nie 'n probleem wees as jy dit doen

ನೀವು ಇದನ್ನು ಮಾಡಿದರೆ ಆಧುನಿಕ ಗಣಕಗಳಲ್ಲಿ, ಈ ಸಮಸ್ಯೆಯನ್ನು ಇರಬಹುದು

in een of twee geïsoleerde gevalle,

ಒಂದು ಅಥವಾ ಎರಡು ಪ್ರತ್ಯೇಕ ಸಂದರ್ಭಗಳಲ್ಲಿ,

maar as jy die gebruiker se insette in 'n lus en stoor vir latere gebruik,

ಆದರೆ ನೀವು ಒಂದು ಆವರ್ತನದಲ್ಲಿ ಬಳಕೆದಾರರ ಇನ್ಪುಟ್ ತೆಗೆದುಕೊಂಡು ನಂತರ ಬಳಕೆಗೆ ಸಂಗ್ರಹಿಸುವ ಬಳಸುತ್ತಿದ್ದರೆ,

kan jy vinnig suig 'n ton van die geheue.

ನೀವು ಬೇಗನೆ ಮೆಮೊರಿಯ ಒಂದು ಟನ್ ಅಪ್ ಹೀರುವಂತೆ ಮಾಡಬಹುದು.

Verder, as die program wat jy skryf is vir 'n kleiner rekenaar -

ಹೆಚ್ಚುವರಿಯಾಗಿ, ನೀವು ನಾವು ಬರೆಯುತ್ತಿದ್ದೇವೆ ಪ್ರೋಗ್ರಾಂ ಒಂದು ಸಣ್ಣ ಕಂಪ್ಯೂಟರ್ ಹೊಂದಿದೆ -

'n toestel soos 'n smartphone of iets anders met 'n beperkte geheue -

ಸೀಮಿತ ಮೆಮೊರಿಯಲ್ಲಿ ಸ್ಮಾರ್ಟ್ಫೋನ್ ಅಥವಾ ಯಾವುದೋ ಒಂದು ಸಾಧನ -

hierdie oplossing probleme sal veroorsaak dat 'n baie vinniger.

ಈ ಪರಿಹಾರವನ್ನು ಸಾಕಷ್ಟು ವೇಗವಾಗಿ ಸಮಸ್ಯೆಗಳಿಗೆ ಕಾರಣವಾಗುತ್ತದೆ.

Die tweede, meer ernstige rede om dit nie doen nie, is dat dit jou program verlaat kwesbare

ಈ ಮಾಡದಿರುವುದು ಎರಡನೇ, ಗಂಭೀರ ಕಾರಣ ಇದು ದುರ್ಬಲ ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಎಲೆಗಳನ್ನು ಅಂದರೆ

wat genoem word 'n buffer oorloop aanval.

ಒಂದು ಅತಿ ಹೆಚ್ಚು ಬಫರ್ ದಾಳಿ ಎಂಬ ಏನನ್ನು ಮಾಡಲು.

In programmering, 'n buffer geheue gebruik word om tydelik inset of uitset data stoor,

ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಒಂದು ಬಫರ್, ತಾತ್ಕಾಲಿಕವಾಗಿ ಇನ್ಪುಟ್ ಅಥವಾ ಹೊರಹೋಗುವ ಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ ಮೆಮೊರಿ ಹೊಂದಿದೆ

wat in hierdie geval is ons 1000-char blok.

ಈ ಸಂದರ್ಭದಲ್ಲಿ ನಮ್ಮ 1000-ಚಾರ್ ಬ್ಲಾಕ್ ಇದು.

'N buffer overflow voorkom wanneer data is verby die einde van die blok geskryf.

ದತ್ತಾಂಶ ವಿಭಾಗಗಳನ್ನು ಕೊನೆಯಲ್ಲಿ ಕಳೆದ ಬರೆಯಲಾಗಿದೆ ಒಂದು ಅತಿ ಹೆಚ್ಚು ಬಫರ್ ಸಂಭವಿಸುತ್ತದೆ.

>> Byvoorbeeld, as 'n gebruiker tik in meer as 1000 karakters.

>> ಉದಾಹರಣೆಗೆ, ಒಂದು ಬಳಕೆದಾರ ವಾಸ್ತವವಾಗಿ 1000 ಕ್ಕೂ ಹೆಚ್ಚು ಅಕ್ಷರಗಳನ್ನು ಟೈಪ್ ಮಾಡಿದರೆ.

Jy dalk ervaar het dit per ongeluk wanneer programmering met skikkings.

ವ್ಯೂಹಗಳನ್ನು ಹೊಂದಿರುವ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ನೀವು ಆಕಸ್ಮಿಕವಾಗಿ ಈ ಅನುಭವಿಸುವ ಸಾಧ್ಯತೆಯಿದೆ.

As jy 'n verskeidenheid van 10 ints, niks stop jy van probeer om te lees of skryf nie

ನೀವು 10 ints ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಹೊಂದಿದ್ದರೆ, ಏನೂ ಓದಲು ಅಥವಾ ಬರೆಯಲು ಪ್ರಯತ್ನಿಸುವಾಗ ನೀವು ನಿಲ್ದಾಣಗಳು

die 15de int.

15 ಇಂಟ್.

Daar is geen saamsteller waarskuwings of foute.

ಯಾವುದೇ ಕಂಪೈಲರ್ ಎಚ್ಚರಿಕೆಗಳನ್ನು ಅಥವಾ ದೋಷಗಳಿವೆ.

Die program het net flaters reguit vorentoe en toegang tot die geheue

ಪ್ರೋಗ್ರಾಂ ಕೇವಲ ನೇರವಾಗಿ ಮುಂದಕ್ಕೆ ಪ್ರಮಾದಗಳ ಮತ್ತು ಮೆಮೊರಿ ಪ್ರವೇಶ

waar dit dink die 15de int sal wees, en dit kan jou ander veranderlikes oorskryf.

ಇದು ಯೋಚಿಸುತ್ತಾನೆ ಅಲ್ಲಿ 15 ಇಂಟ್ ಆಗಿರುತ್ತದೆ, ಮತ್ತು ಇದು ನಿಮ್ಮ ಇತರ ಅಸ್ಥಿರ ಬದಲಿಸಿ.

In die ergste geval, kan jy oorskryf sommige van jou program se interne

ಕೆಟ್ಟ ಸಂದರ್ಭದಲ್ಲಿ, ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಆಂತರಿಕ ಕೆಲವು ಬದಲಿಸಿ

beheermeganismes, om werklik veroorsaak dat jou program uitvoer verskillende instruksies

ನಿಯಂತ್ರಣ ಕಾರ್ಯವಿಧಾನಗಳು, ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಕಾರಣವಾಗುತ್ತದೆ ವಾಸ್ತವವಾಗಿ ವಿವಿಧ ಸೂಚನೆಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು

as wat jy bedoel.

ನೀವು ಉದ್ದೇಶಿಸಿದ ಹೆಚ್ಚು.

>> Nou, dit is nie algemeen is dit per ongeluk doen,

>> ಈಗ, ಇದು, ಆಕಸ್ಮಿಕವಾಗಿ ಈ ಮಾಡಲು ಸಾಮಾನ್ಯ ಅಲ್ಲ

maar dit is 'n redelik algemene tegniek wat die slegte ouens gebruik om programme te breek

ಆದರೆ ಈ ಕೆಟ್ಟ ಜನರು ಕಾರ್ಯಕ್ರಮಗಳು ಮುರಿಯಲು ಬಳಸುವ ಒಂದು ಸರ್ವೇಸಾಮಾನ್ಯ ತಂತ್ರ

en kwaadwillige kode op ander mense se rekenaars.

ಮತ್ತು ಇತರ ಜನರ ಕಂಪ್ಯೂಟರ್ಗಳಲ್ಲಿ ದುರುದ್ದೇಶಪೂರಿತ ಕೋಡ್ ಪುಟ್.

Daarom kan ons nie net gebruik ons naïef oplossing.

ಆದ್ದರಿಂದ, ನಾವು ನಮ್ಮ ನಿಷ್ಕಪಟ ಪರಿಹಾರ ಬಳಸಲು ಸಾಧ್ಯವಿಲ್ಲ.

Ons moet 'n manier om te verhoed dat ons programme van kwesbare

ನಾವು ಖಂಡನೀಯವಾಗಿರುವ ನಮ್ಮ ಕಾರ್ಯಕ್ರಮಗಳನ್ನು ತಡೆಗಟ್ಟಲು ಒಂದು ದಾರಿ ಬೇಕಿದೆ

aan 'n buffer oorloop aanval.

ಒಂದು ಅತಿ ಹೆಚ್ಚು ಬಫರ್ ದಾಳಿಗೆ.

Om dit te kan doen, moet ons seker maak dat ons buffer kan groei soos ons lees

ಇದನ್ನು ಮಾಡಲು, ನಾವು ಓದುವ ನಮ್ಮ ಬಫರ್ ಬೆಳೆಯುತ್ತವೆ ಎಂಬುದನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ ಅಗತ್ಯವಿದೆ

meer insette van die gebruiker.

ಬಳಕೆದಾರ ಹೆಚ್ಚಿನ ಇನ್ಪುಟ್.

Die oplossing? Ons gebruik 'n hoop toegekende buffer.

ಪರಿಹಾರ? ನಾವು ರಾಶಿ ನಿಯೋಜಿತವಾದ ಬಫರ್ ಅನ್ನು.

Aangesien ons dit kan die grootte van die gebruik van die grootte van die realloc funksie,

ನಾವು ಮರುಗಾತ್ರಗೊಳಿಸಬಹುದು ಇದು, ಗಣಕತೆರೆ realloc ಕಾರ್ಯ ಬಳಸಿ

en ons hou van twee getalle - die indeks van die volgende leë slot in die buffer

ಮತ್ತು ನಾವು ಎರಡು ಸಂಖ್ಯೆಗಳ ಟ್ರ್ಯಾಕ್ - ಮುಂದಿನ ಖಾಲಿ ಸ್ಲಾಟ್ ಸೂಚಕ ಬಫರ್

en die lengte of die kapasiteit van die buffer.

ಮತ್ತು ಉದ್ದ ಅಥವಾ ಬಫರ್ ಸಾಮರ್ಥ್ಯ.

Ons lees in die karakters van die gebruiker een op 'n tyd deur gebruik te maak van die fgetc funksie.

ನಾವು fgetc ಕಾರ್ಯಕಾರಿತ್ವ ಬಳಸಿಕೊಂಡು ಒಂದು ಸಮಯದಲ್ಲಿ ಬಳಕೆದಾರ ಒಂದರಿಂದ ಅಕ್ಷರಗಳನ್ನು ಓದಲು.

Die argument van die fgetc funksie neem - stdin - is 'n verwysing na die standaard inset string,

stdin - - fgetc ಕಾರ್ಯ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ಆರ್ಗ್ಯುಮೆಂಟ್, ಪ್ರಮಾಣಿತ ಇನ್ಪುಟ್ ಸ್ಟ್ರಿಂಗ್ ಉಲ್ಲೇಖವಾಗಿತ್ತು

wat is 'n preconnected invoer kanaal wat gebruik word om die gebruiker se insette oor te dra

ಇದು ಬಳಕೆದಾರರ ಇನ್ಪುಟ್ ವರ್ಗಾಯಿಸಲು ಬಳಸುವ preconnected ಇನ್ಪುಟ್ ಚಾನಲ್ನಲ್ಲಿ

van die terminale na die program.

ಟರ್ಮಿನಲ್ ನಿಂದ ಕಾರ್ಯಕ್ರಮಕ್ಕೆ.

>> Wanneer die gebruiker tipes in 'n nuwe karakter, gaan ons om te sien of die indeks

>> ಯಾವಾಗ ಒಂದು ಹೊಸ ಪಾತ್ರದ ಬಳಕೆದಾರ ರೀತಿಯ ನಾವು ಪರೀಕ್ಷಿಸಿ ವೇಳೆ ಸೂಚ್ಯಂಕ

van die volgende gratis slot plus 1 is groter as die kapasiteit van die buffer.

ಮುಂದಿನ ಉಚಿತ ಸ್ಲಾಟ್ ಆಫ್ ಪ್ಲಸ್ 1 ಬಫರ್ ಸಾಮರ್ಥ್ಯ ಹೆಚ್ಚಾಗಿದೆ.

Die 1 kom in want as die volgende indeks is 5,

+1, ಮುಂದಿನ ಉಚಿತ ಸೂಚ್ಯಂಕ 5 ವೇಳೆ ಏಕೆಂದರೆ ಬರುತ್ತದೆ

dan is ons buffer se lengte moet 6 danksy 0 kruip.

ನಂತರ ನಮ್ಮ ಬಫರ್ ಉದ್ದವು 6 ಧನ್ಯವಾದಗಳು 0 ಅನುಕ್ರಮಣಿಕೆ ಇರಬೇಕು.

As ons het hardloop uit van die ruimte in die buffer, dan sal ons probeer om dit te resize,

ನಾವು ಬಫರ್ ಸ್ಥಳವು ನೀವು, ನಾವು, ಅದನ್ನು ಮರುಗಾತ್ರಗೊಳಿಸಲು ಪ್ರಯತ್ನ

te verdubbel sodat ons kap op die aantal kere wat ons die grootte van

ನಾವು ಮರುಗಾತ್ರಗೊಳಿಸಬಹುದು ಆ ಬಾರಿ ಸಂಖ್ಯೆಯಲ್ಲಿ ಕಡಿಮೆ ಇದರಿಂದ ಡಬಲ್

indien die gebruiker in 'n baie lang string tik.

ಬಳಕೆದಾರ ನಿಜವಾಗಿಯೂ ಬಹಳ ಸ್ಟ್ರಿಂಗ್ ನಮೂದಿಸುವುದನ್ನು ವೇಳೆ.

As die tou gekry het te lank, of as ons hardloop uit hoopgeheue,

ಸ್ಟ್ರಿಂಗ್ ತುಂಬಾ ನೆತ್ತಿಗೇರಿದೆ ಅಥವಾ ನಾವು ರಾಶಿ ಮೆಮೊರಿಯ ರನ್ ಔಟ್ ವೇಳೆ ವೇಳೆ,

ons vry om ons buffer en terugkeer null.

ನಮ್ಮ ಬಫರ್ ಮತ್ತು ರಿಟರ್ನ್ ಶೂನ್ಯ ಮುಕ್ತಗೊಳಿಸಲು.

>> Ten slotte, ons voeg die kar aan die buffer.

>> ಅಂತಿಮವಾಗಿ, ನಾವು ಬಫರ್ ಗೆ ಚಾರ್ ಸೇರಿಸಿಕೊಳ್ಳುತ್ತವೆ.

Sodra die gebruiker treffers betree of terugkeer, die sein van 'n nuwe reël,

ಬಳಕೆದಾರ ಹಿಟ್ ನಮೂದಿಸಿ ಅಥವಾ ಮರಳಿ, ಹೊಸ ಲೈನ್ ಸಂಕೇತ, ಒಮ್ಮೆ

of die spesiale char - beheer d - wat dui op 'n einde van die insette,

ಅಥವಾ ವಿಶೇಷ ಚಾರ್ - ನಿಯಂತ್ರಣ D - ಇನ್ಪುಟ್ ಒಂದು ಕೊನೆಯಲ್ಲಿ ಸಂಕೇತಗಳನ್ನು,

ons doen 'n tjek te sien as die gebruiker eintlik getik in enigiets.

ನಾವು ಬಳಕೆದಾರರು ವಾಸ್ತವವಾಗಿ ಎಲ್ಲ ಏನು ಬೆರಳಚ್ಚಿಸಿದ ನೀವು ಒಂದು ಚೆಕ್ ಮಾಡಿ.

Indien nie, keer ons terug null.

ಅಲ್ಲ, ನಾವು ಶೂನ್ಯ ಹಿಂತಿರುಗಿ.

Andersins, omdat ons buffer is waarskynlik groter as wat ons nodig het,

ಇಲ್ಲದಿದ್ದರೆ, ನಮ್ಮ ಬಫರ್ ನಾವು ಅವಶ್ಯಕತೆ ಹೆಚ್ಚು ಬಹುಶಃ ದೊಡ್ಡ ಕಾರಣ,

in die ergste geval dit is byna twee keer so groot as wat ons nodig het

ಕೆಟ್ಟ ಸಂದರ್ಭದಲ್ಲಿ ನಮಗೆ ಸುಮಾರು ಎರಡು ಪಟ್ಟು ದೊಡ್ಡದಾಗಿರುವುದರಿಂದ

aangesien ons elke keer as ons die grootte verdubbel,

ನಾವು ಗಾತ್ರ ಬದಲಾವಣೆ ಪ್ರತಿ ಬಾರಿ ಡಬಲ್, ಏಕೆಂದರೆ

maak ons 'n nuwe kopie van die string met behulp van die bedrag van die ruimte wat ons nodig het.

ನಾವು ಅಗತ್ಯವಿರುವ ಜಾಗವನ್ನು ಕೇವಲ ಪ್ರಮಾಣವನ್ನು ಬಳಸಿಕೊಂಡು ಸ್ಟ್ರಿಂಗ್ ಹೊಸ ನಕಲನ್ನು ಮಾಡಿ.

Ons voeg 'n ekstra 1 aan die malloc oproep,

ನಾವು, malloc ಕರೆಗೆ ಹೆಚ್ಚುವರಿ 1 ಸೇರಿಸಿ

sodat daar ruimte vir die spesiale null terminator karakter - die \ 0,

\ 0, - ವಿಶೇಷ ಶೂನ್ಯ ಟರ್ಮಿನೇಟರ್ ಪಾತ್ರಕ್ಕೆ ಸ್ಥಳವಿರುವ ಎಂದು ಆದ್ದರಿಂದ

wat ons voeg aan die tou wanneer ons in die res van die karakters kopieer,

ಇದು ನಾವು ಪಾತ್ರಗಳು ಉಳಿದ ನಕಲಿಸಿ ಒಮ್ಮೆ ನಾವು ಸ್ಟ್ರಿಂಗ್ ಗೆ ಸೇರಿಸಲು,

met behulp van strncpy in plaas van strcpy

ಬದಲಿಗೆ strcpy ಆಫ್ strncpy ಬಳಸಿ

sodat ons kan spesifiseer presies hoeveel karakters ons wil kopieer.

ಆದ್ದರಿಂದ ನಾವು ನಕಲಿಸಲು ಬಯಸುವ ನಿಖರವಾಗಿ ಎಷ್ಟು ಅಕ್ಷರಗಳನ್ನು ಸೂಚಿಸಬಹುದು.

Strcpy afskrifte totdat dit tref 'n \ 0.

ಇದು \ 0 ತಾಗುತ್ತದೆ ರವರೆಗೆ Strcpy ನಕಲಿಸುತ್ತದೆ.

Dan sal ons vry om ons buffer en die standaard van die afskrif aan die oproeper.

ನಂತರ ನಮ್ಮ ಬಫರ್ ಮುಕ್ತಗೊಳಿಸಲು ಮತ್ತು ಕಾಲರ್ ಗೆ ಪ್ರತಿಯನ್ನು ಮರಳಿ.

>> Wie het geweet so 'n eenvoudige-oënskynlike funksie kan so ingewikkeld wees?

>> ಯಾರು ಇಂತಹ ಸರಳ ತೋರಿಕೆಯ ಕಾರ್ಯ ಸಂಕೀರ್ಣಗೊಳಿಸಿದೆ ಎಂದು ತಿಳಿದಿದ್ದರು?

Nou weet jy wat gaan in die CS50 biblioteek.

ಈಗ ನೀವು CS50 ಗ್ರಂಥಾಲಯದ ಹೋಗುತ್ತದೆ ಎಂಬುದನ್ನು ತಿಳಿಯೋಣ.

>> My naam is Nate Hardison, en dit is CS50.

>> ನನ್ನ ಹೆಸರು ನೇಟ್ Hardison ಆಗಿದೆ, ಮತ್ತು ಈ CS50 ಹೊಂದಿದೆ.

[CS50.TV]