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

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