Advance-C/C2/Storage-class-specifiers/Telugu

From Script | Spoken-Tutorial
Revision as of 11:08, 12 October 2017 by Madhurig (Talk | contribs)

(diff) ← Older revision | Latest revision (diff) | Newer revision → (diff)
Jump to: navigation, search
Time Narration
00:01 స్పోకెన్ ట్యుటోరియల్ లో స్టోరేజ్ క్లాస్ స్పెసిఫయర్స్ ఇన్ C అనే ట్యుటోరియల్ కు స్వాగతం.
00:07 ఈ ట్యుటోరియల్ లో మనం స్టోరేజ్ క్లాస్ స్పెసిఫయర్స్, auto కీవర్డ్, static కీవర్డ్, extern కీవర్డ్, register కీవర్డ్ గురించి ఒక ఉదాహరణతో నేర్చుకొంటాము.
00:22 ఈ ట్యుటోరియల్ కోసం నేను ఉపయోగిస్తున్నది, Ubuntu OS వర్షన్ 11.10 మరియు Ubuntu పై gcc కంపైలర్ వర్షన్ 4.6.1.
00:34 ఈ ట్యుటోరియల్ ను నేర్చుకొనుటకు, మీకు C ట్యుటోరియల్స్ గురించి తెలుసుండాలి.
00:41 లేకపోతే సంబంధిత ట్యుటోరియల్స్ కోసం చూపిన మా వెబ్-సైట్ ను చూడండి.
00:47 నేను స్టోరేజ్ క్లాస్ యొక్క పరిచయంతో మొదలు పెడతాను.
00:52 స్పెసిఫయర్స్ కంపైలర్ కు వేరియబుల్స్ ఎక్కడ స్టోర్ కావాలో,
00:57 ఎలా స్టోర్ కావాలో చెబుతుంది.
00:59 అదేవిధంగా, వేరియబుల్స్ యొక్క ప్రారంభ విలువ మరియు
01:03 వేరియబుల్స్ యొక్క జీవిత కాలం గురించి చెబుతుంది.
01:06 సింటాక్స్: storage_specifier data_type variable _name.
01:13 స్టోరేజ్ క్లాస్ స్పెసిఫయర్స్ లో రకాలు,

auto, static, extern, register.

01:21 ముందుగా, auto కీవర్డ్ తో మొదలు పెడదాం.
01:24 auto కీవర్డ్ automatic వేరియబుల్ ను డిక్లేర్ చేస్తుంది.
01:28 దానికి లోకల్ స్కోప్ ఉంటుంది.
01:30 keywords ఆటోమేటిక్ గా అసైన్ చేయబడవు.
01:34 మీరు డిక్లేర్ చేస్తున్నపుడు తప్పనిసరిగా keywords కు విలువలు అసైన్ చేయాలి.
01:39 కీవర్డ్స్ యొక్క స్టోరేజ్ స్పేస్ CPU మెమొరీ.
01:43 మనము ఒక ప్రోగ్రాంతో చూద్దాం. నేను ఎడిటర్ నందు కోడ్ టైప్ చేసి ఉంచాను. నేను ఇప్పుడు అది ఓపెన్ చేస్తాను.
01:49 మన ఫైల్ పేరు auto.c అని గమనించండి.
01:54 మనం increment() అను ఫంక్షన్ ను డిక్లేర్ చేశాము.
01:58 ఇది మన main() ఫంక్షన్
02:00 main() ఫంక్షన్ నందు increment() ఫంక్షన్ 4 సార్లు పిలువబడింది.
02:06 తరువాత return 0 కలదు.
02:10 ఫంక్షన్ డెఫినిషన్ గురించి చూద్దాం.
02:14 ఇక్కడ మనం i వేరియబుల్ ను auto int గా డిక్లేర్ చేశాము. అది లోకల్ స్కోప్ కలిగియున్నది.
02:21 తరువాత మనం printf ను ఉపయోగించి i విలువ ను ప్రదర్శిస్తాము.
02:26 i విలువ ఇక్కడ ఇంక్రిమెంట్ చేయబడినది.
02:30 Ctrl, Alt మరియు T లను కీబోర్డ్ పై ఒకేసారి ఉపయోగించి టెర్మినల్ విండో తెరుద్దాం.
02:38 కంపైల్ చేయుటకు, gcc space auto.c space hyphen o space auto అని టైప్ చేసి, ఎంటర్ నొక్కండి.
02:48 dot slash auto అని టైప్ చెయ్యండి.
02:51 వచ్చిన ఔట్పుట్ 0.
02:54 తిరిగి మన ప్రోగ్రాంకు వద్దాం.
02:57 ప్రోగ్రాం లో main కు పైన auto వెరియేబుల్ కు ప్రారంభవిలువ ను ఇద్దాం.
03:02 నేను ఈ డిక్లరేషన్ మరియు ఇనీషియాలైసేషన్ ను ఇక్కడ నుండి కట్ చేసి పైన పేస్ట్ చేస్తాను మరియు save పై క్లిక్ చేస్తాను.
03:14 టెర్మినల్ నందు ఎగ్జిక్యూట్ చేద్దాం. అప్-యారో కీ రెండు సార్లు ప్రెస్ చేసి ఎంటర్ నొక్కండి.
03:22 మనకు file-scope declaration of 'i' specifies 'auto' అను ఎర్రర్ ఇస్తుంది.
03:29 ఇది ఎందువలన అంటే auto వేరియబుల్ ఫంక్షన్ కు లోకల్ అగును కనుక.
03:34 కాబట్టి మనం గ్లోబల్ గా ఇనీషియాలైజ్ చేయలేము.
03:37 ఎర్రర్ ను సరిచేద్దాం. తిరిగి మన ప్రోగ్రాం లోనికి రండి.
03:42 దీనిని ఇక్కడ నుండి తీసివేసి ఇక్కడ పేస్ట్ చెయ్యండి.
03:47 save పై క్లిక్ చేసి, టెర్మినల్ వద్ద ఎగ్జిక్యూట్ చెయ్యండి.
03:52 అప్-యారో కీ ప్రెస్ చేసి, ఇంతకు ముందు కమాండ్ ను పిలవండి.
03:57 ఎంటర్ నొక్కడి dot slash auto అని టైప్ చేసి తిరిగి ఎంటర్ నొక్కండి.
04:03 అవును ఇది పనిచేస్తుంది వచ్చిన ఔట్పుట్ 0.
04:07 ఇది ఎందువలనంటే మనం దానికి జీరో (0) విలువ ను ఇచ్చాము కాబట్టి.
04:13 ఇప్పుడు static వేరియబుల్ గురుంచి చూద్దాం.
04:16 ఇంత క్రితం ట్యుటోరియలో నే మనం static వేరియబుల్ గురించి చదువుకొనినను, నేను ఇక్కడ దానిగురించి సంక్షిప్తంగా వివరిస్తాను.
04:24 static వేరియబుల్స్ 0 తో ఇనీషియాలైజ్ చేయబడతాయి.
04:28 ప్రోగ్రాం కంట్రోల్ బ్లాక్ ను దాటిన తరువాత కూడా అవి నాశనం కావు.
04:35 వేరియబుల్ యొక్క విలువ ఫంక్షన్ యొక్క వేరువేరు కాల్స్ మధ్య అందుబాటులో ఉండును.
04:41 వీటి స్టోరేజ్ స్పేస్ CPU మెమొరీ
04:45 ఒక ఉదాహరణ చూద్దాం. నేను అదే కోడ్ ఫైల్ ను ఎడిట్ చేస్తాను.
04:51 తిరిగి మన ప్రోగ్రాంకు వద్దాం.
04:54 Ctrl, Shift మరియు S ఒకేసారి ప్రెస్ చెయ్యండి.
05:01 ఇప్పుడు నేను ఫైల్ పేరు ను static అని మారుస్తాను. save పై క్లిక్ చెయ్యండి.
05:10 ఇప్పుడు నేను i యొక్క ఇనిష్యాలైజెషన్ ను static int i equals to zeroకు మారుస్తాను. save పై క్లిక్ చెయ్యండి.
05:23 ఏమి జరుగునో గమనించండి. టెర్మినల్ వద్ద ఫైల్ ను ఎగ్జిక్యూట్ చెయ్యండి.
05:30 gcc space static.c space hyphen o space stat అని టైప్ చేసి ఎంటర్ నొక్కండి.
05:41 dot slash stat అని టైప్ చేసి ఎంటర్ నొక్కండి.
05:46 0, 1, 2, 3 అని ఔట్పుట్ డిస్ప్లే అగును.
05:51 ఇది ఎందువలనంటే static వేరియబుల్స్ గ్లోబల్ వేరియబుల్స్ కాబట్టి
05:56 ఒక ఫంక్షన్ లో డిక్లేర్ చేయబడ్డ స్టాటిక్ వేరియబుల్ యొక్క స్కోప్ ఆ ఫంక్షన్ కు లోకల్ అగును.
06:03 అవి వాటి విలువను ఫంక్షన్ యొక్క వేరువేరు కాల్స్ మధ్య కోల్పోవు.
06:08 ఇప్పుడు extern కీవర్డ్ గురించి నేర్చుకొందాం.
06:12 extern వేరియబుల్స్ యొక్క scope ప్రోగ్రాం అంతా ఉంటుంది.
06:17 extern వేరియబుల్స్ యొక్క డెఫినిషన్ C ప్రోగ్రాం లో ఎక్కడైనా ఉండవచ్చు.
06:23 extern వేరియబుల్స్ అప్రమేయంగా 0 తో ఇనీషియాలైజ్ చేయబడతాయి.
06:28 అవి ప్రోగ్రాం నందు అన్ని ఫంక్షన్స్ లలో పొందబడును.
06:33 ఇవి CPU మెమొరీ నందు స్టోర్ చేయబడతాయి.
06:36 ఒక ఉదాహరణను చూద్దాం.
06:38 నేను ఎడిటర్ నందు కోడ్ టైప్ చేసి ఉంచాను. నేను ఇప్పుడు అది ఓపెన్ చేస్తాను.
06:42 మన ఫైల్ పేరు extern.c అనిగమనించండి.
06:47 నేను integer variable x to 10 అని ఒక వేరియబుల్ ను ఇనీషిలైజ్ చేశాను.
06:54 ఇది మన main () ఫంక్షన్. ఈ main () ఫంక్షన్ నందు నేను ఒక extern integer వేరియబుల్ y ను డిక్లేర్ చేశాను.
07:03 printf() స్టేట్మెంట్ ను ఉపయోగించి x మరియు, yల యొక్క విలువను ప్రదర్శిస్తాము. ఇది మన return స్టేట్మెంట్.
07:12 main () ఫంక్షన్ క్లోజ్ అయిన తరువాత నేను y కు 50 ను ఇచ్చాను.
07:18 టెర్మినల్ కు వెళ్ళి, ouput ఏమిటో చూద్దాం.
07:24 gcc space extern.c space hyphen o space ext అని టైప్ చేసి, ఎంటర్ నొక్కండి.
07:35 dot slash ext అని టైప్ చేసి, ఎంటర్ నొక్కండి.
07:40 ఔట్పుట్ ఈ విధంగా ఉండును.

The value of x is 10

The value of y is 50

07:48 మనం చదువు కొనినట్టు extern కీవర్డ్ యొక్క విలువ main ప్రోగ్రాం అంతను ఉంటుంది.
07:55 దీనిని మనం మన ప్రోగ్రాం లో ఎక్కడైనా డిఫైన్ చెయ్యవచ్చు.
07:59 రెండు వాక్యాలు జస్టిఫై చేయబడ్డాయి.
08:02 ఇప్పుడు register కీవర్డ్ గురించి చూద్దాం.
08:06 register వేరియబుల్స్ మాములు వేరియబుల్స్ కంటే వేగంగా access చేయబడతాయి.
08:13 అవి మెయిన్ మెమొరీ నందు కాకుండా రిజిస్టర్ మెమొరీ నందు స్టోర్ అగును.
08:19 రిజిస్టర్ మెమొరీ సైజ్ తక్కువ కావున మనం కొన్ని వేరియబుల్స్ ను మాత్రమే స్టోర్ చేయగలము.
08:25 అవి 16bit, 32bit, లేదా 64bit లలో ఉండును.
08:30 ఒక ఉదాహరణను చూద్దాం. నేను ఎడిటర్ నందు కోడ్ టైప్ చేసి ఉంచాను. నేను ఇప్పుడు అది ఓపెన్ చేస్తాను.
08:37 మన ఫైల్ పేరు register.c అనిగమనించండి.
08:42 ఇక్కడ మనం ఒక register integer వారియేబుల్ ను డిక్లేర్ చేశాము.
08:47 ఈ వేరియబుల్ డైరెక్ట్ గా రిజిస్టర్ మెమొరీ లో స్టోర్ చేయబడును.
08:53 ఇది for లూప్. అది i విలువను 1 నుండి 5 వరకు డిస్ప్లే చేయును.
08:59 ఇది i యొక్క విలువ ను ప్రింట్ చేస్తుంది.
09:03 మనం ప్రోగ్రాం కోడ్ ను ఎగ్జిక్యూట్ చేసి చూద్దాం.
09:07 కంపైల్ చేయుటకు gcc space register.c space hyphen o space register అని టైప్ చేసి,
09:17 ఎంటర్ నొక్కండి. dot slash register అని టైప్ చేసి, ఎంటర్ నొక్కండి.
09:25 output ఈ విధంగా డిస్ప్లే చేయబడుట చూడవచ్చు Values stored in register memory 1 2 3 4 5.
09:34 మనం ట్యుటోరియల్ చివరకు వచ్చాము. సంగ్రహంగా,
09:39 ఈ ట్యుటోరియల్ లో మనం నేర్చుకొన్నది. స్టోరేజ్ క్లాస్ స్పెసిఫయర్స్,

auto కీవర్డ్, static కీవర్డ్, extern కీవర్డ్, register కీవర్డ్.

09:52 అసైన్మెంట్ గా, మొదటి 5 సంఖ్యల మొత్తం కనుగొనుటకు ప్రోగ్రాం వ్రాయండి.
09:59 ప్రోగ్రాం నందు auto మరియు static కీవర్డ్స్ ను డిక్లేర్ చేయుము.
10:04 ఈ లింక్ వద్ద అందుబాటులో వున్న వీడియో చూడండి.
10:07 ఇది స్పోకెన్ ట్యుటోరియల్ యొక్క సారాంశంను ఇస్తుంది.
10:11 మీకు మంచి బ్యాండ్ విడ్త్ లేక పొతే వీడియో ని డౌన్లోడ్ చేసి చూడవచ్చు.
10:16 స్పోకెన్ ట్యుటోరియల్ ప్రాజెక్ట్ టీం: స్పోకెన్ ట్యూటోరియల్స్ ని ఉపయోగించి వర్క్ షాప్లను నిర్వహిస్తుంది.
10:22 ఆన్ లైన్ పరీక్ష లో ఉత్తీర్ణులైన వారికీ సర్టిఫికెట్లు కూడా ఇస్తుంది.

మరిన్ని వివరాలకు, దయచేసి contact@spoken-tutorial.orgకు మెయిల్ చెయ్యండి.

10:33 స్పోకెన్ ట్యుటోరియల్ అనేది టాక్ టు ఏ టీచర్ అనే ప్రాజెక్ట్ లో ఒక భాగము.
10:38 దీనికి ICT, MHRD, భారత ప్రభుత్వము ద్వారా నేషనల్ మిషన్ ఆన్ ఎడ్యుకేషన్ సహకారం అందిస్తోంది.
10:45 ఈ మిషన్ గురించి మరింత సమాచారము ఈ లింక్ లో అందుబాటులో ఉంది. http://spoken-tutorial.org\NMEICT-Intro.
10:52 ఈ ట్యూటోరియల్ ను తెలుగు లోకి అనువదించింది స్వామి మరియు నేను ఉదయ లక్ష్మి మీ వద్ద సెలవు తీసుకుంటున్నాను ధన్యవాదాలు.

Contributors and Content Editors

Madhurig, Yogananda.india