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

“Time”	“Narration”
00:01	ਸਤਿ ਸ਼੍ਰੀ ਅਕਾਲ ਦੋਸਤੋ, ‘Storage class specifiers’ ‘ਤੇ ਸਪੋਕਨ ਟਿਊਟੋਰਿਅਲ ਵਿੱਚ ਤੁਹਾਡਾ ਸਾਰਿਆ ਦਾ ਸਵਾਗਤ ਹੈ ।
00:07	ਇਸ ਟਿਊਟੋਰਿਅਲ ਵਿੱਚ ਅਸੀਂ ਕੁੱਝ ਉਦਾਹਰਣਾਂ ਦੀ ਮੱਦਦ ਨਾਲ ਹੇਠ ਦਿੱਤੇ ਦੇ ਬਾਰੇ ਵਿੱਚ ਸਿੱਖਾਂਗੇ ‘Storage class specifiers’ ‘auto keyword’ ‘static keyword’ ‘extern keyword’ ‘register keyword’
00:22	ਇਸ ਟਿਊਟੋਰਿਅਲ ਦੇ ਲਈ ਮੈਂ ਵਰਤੋਂ ਕਰ ਰਿਹਾ ਹਾਂ ‘ਉਬੰਟੁ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਵਰਜ਼ਨ 11.10’ ਅਤੇ ‘ਉਬੰਟੁ’ ‘ਤੇ ‘gcc ਕੰਪਾਇਲਰ ਵਰਜ਼ਨ 4.6.1’
00:34	ਇਸ ਟਿਊਟੋਰਿਅਲ ਦੀ ਪਾਲਣਾ ਕਰਨ ਦੇ ਲਈ ਤੁਹਾਨੂੰ C ਟਿਊਟੋਰਿਅਲਸ ਤੋਂ ਜਾਣੂ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ ।
00:41	ਜੇ ਨਹੀਂ ਤਾਂ ਸੰਬੰਧਿਤ ਟਿਊਟੋਰਿਅਲਸ ਦੇ ਲਈ ਕ੍ਰਿਪਾ ਕਰਕੇ ਸਾਡੀ ਦਰਸਾਈ ਗਈ ਵੈੱਬਸਾਈਟ ‘ਤੇ ਜਾਓ ।
00:47	ਮੈਂ ‘storage class specifiers’ ਦੇ ਜਾਣ ਪਹਿਚਾਣ ਦੇ ਨਾਲ ਸ਼ੁਰੂ ਕਰਾਂਗਾ ।
00:52	* ‘Specifiers’ ਕੰਪਾਇਲਰ ਨੂੰ ਦੱਸਦੇ ਹਨ ਕਿ ਵੈਰੀਏਬਲ ਨੂੰ ਕਿੱਥੇ ਇੱਕਠਾ ਕਰਨਾ ਹੈ ।
00:57	‘ਵੈਰੀਏਬਲ’ ਨੂੰ ਕਿਵੇਂ ਸੇਵ ਕਰਦੇ ਹਨ ।
00:59	‘ਵੈਰੀਏਬਲ’ ਦੀ ਸ਼ੁਰੁਆਤੀ ਵੈਲਿਊ ਕੀ ਹੁੰਦੀ ਹੈ ।
01:03	‘ਵੈਰੀਏਬਲ’ ਦਾ ਲਾਇਫ ਟਾਇਮ
01:06	ਸਿੰਟੈਕਸ ਹੈ: ‘storage_specifier data_type variable _name’
01:13	ਸਟੋਰੇਜ ਟਾਈਪ ਸਪੇਸੀਫਾਇਰ ਦੀਆਂ ਹੇਠ ਦਿੱਤੀਆਂ ਕਿਸਮਾਂ ਹੁੰਦੀਆਂ ਹਨ: ‘auto’ ‘static’ ‘extern’ ‘register’
01:21	ਹੁਣ ‘ਆਟੋ ਕੀਵਰਡ’ ਦੇ ਨਾਲ ਸ਼ੁਰੂ ਕਰਦੇ ਹਾਂ ।
01:24	‘ਆਟੋ ਕੀਵਰਡ’ ‘ਆਟੋਮੈਟਿਕ ਵੈਰੀਏਬਲ’ ਐਲਾਨ ਜਾਂ ਡਿਕਲੇਅਰ ਕਰਦਾ ਹੈ ।
01:28	ਇਹ ਲੋਕਲ ਸਕੋਪ ਰੱਖਦਾ ਹੈ ।
01:30	ਕੀਵਰਡਸ ਆਪਣੇ-ਆਪ ਹੀ ਇਨਿਸ਼ਿਅਲਾਇਜਡ ਨਹੀਂ ਹੁੰਦੇ ਹਨ ।
01:34	ਤੁਹਾਨੂੰ ਐਲਾਨ ਜਾਂ ਡਿਕਲੇਅਰ ਦੇ ਦੌਰਾਨ ‘ਕੀਵਰਡਸ’ ਨੂੰ ਸਪਸ਼ਟ ਰੂਪ ਨਾਲ ਇਨਿਸ਼ਿਅਲਾਇਜ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ ।
01:39	‘ਕੀਵਰਡਸ’ ਦੀ ਸਟੋਰੇਜ ਸਪੇਸ ‘CPU ਮੈਮੋਰੀ’ ਹੁੰਦੀ ਹੈ ।
01:43	ਹੁਣ ਇੱਕ ਉਦਾਹਰਣ ਵੇਖਦੇ ਹਾਂ । ਮੇਰੇ ਕੋਲ ਇੱਕ ਕੋਡ ਫਾਇਲ ਹੈ; ਹੁਣ ਇਸ ਨੂੰ ਵੇਖਦੇ ਹਾਂ ।
01:49	ਨੋਟ ਕਰੋ ਕਿ ਸਾਡੀ ਫਾਇਲ ਦਾ ਨਾਮ ‘auto.c’ ਹੈ ।
01:54	ਅਸੀਂ ‘increment’ ਦੀ ਤਰ੍ਹਾਂ ਇੱਕ ਫੰਕਸ਼ਨ ਐਲਾਨ ਜਾਂ ਡਿਕਲੇਅਰ ਕਰ ਲਿਆ ਹੈ ।
01:58	ਇਹ ‘ਮੇਨ ਫੰਕਸ਼ਨ’ ਹੈ ।
02:00	ਮੇਨ ਫੰਕਸ਼ਨ ਵਿੱਚ, ‘increment’ ‘ਫੰਕਸ਼ਨ’ ਚਾਰ ਵਾਰ ਕਾਲ ਹੁੰਦਾ ਹੈ ।
02:06	ਫਿਰ ਸਾਡੇ ਕੋਲ ‘return 0 statement’ ਹੈ ।
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	ਟਾਈਪ ਕਰੋ: ‘ਡਾਟ ਸਲੈਸ਼ auto
02:51	ਆਉਟਪੁਟ ਜ਼ੀਰੋ ਹੈ ।
02:54	ਹੁਣ ਆਪਣੇ ਪ੍ਰੋਗਰਾਮ ‘ਤੇ ਵਾਪਸ ਆਉਂਦੇ ਹਾਂ ।
02:57	ਹੁਣ ਮੇਨ ਫੰਕਸ਼ਨ ਦੇ ਉੱਪਰ ‘auto variable I’ ਨੂੰ ਇਨਿਸ਼ਿਅਲਾਇਜ ਕਰਦੇ ਹਾਂ ।
03:02	ਮੈਂ ਇਸ ਐਲਾਨ ਅਤੇ ‘ਇਨਿਸ਼ਿਅਲਾਇਜੇਸ਼ਨ’ ਨੂੰ ਇੱਥੋਂ ਕਟ ਕਰਾਂਗਾ ਅਤੇ ਇੱਥੇ ਪੇਸਟ ਕਰਾਂਗਾ । ‘Save’ ‘ਤੇ ਕਲਿਕ ਕਰਾਂਗਾ ।
03:14	ਹੁਣ ‘ਟਰਮੀਨਲ’ ‘ਤੇ ਚਲਾਉਂਦੇ ਹਾਂ । ਅਪ ਐਰੋ ਕੀ ਦੋ ਵਾਰ ਦਬਾਓ । ਐਂਟਰ ਦਬਾਓ ।
03:22	ਸਾਨੂੰ ਇੱਕ ਐਰਰ ਮਿਲਦੀ ਹੈ: ‘file - scope declaration of i specifies auto’
03:29	ਅਜਿਹਾ ਇਸ ਲਈ ਹੈ ਕਿਉਂਕਿ ਇੱਕ ਆਟੋ ਵੈਰੀਏਬਲ ਫੰਕਸ਼ਨ ਦੇ ਲਈ ਲੋਕਲ ਹੈ ।
03:34	ਅਸੀਂ ਇਸ ਨੂੰ ਗਲੋਬਲੀ ਇਨਿਸ਼ਿਅਲਾਇਜ ਨਹੀਂ ਕਰ ਸਕਦੇ ।
03:37	ਹੁਣ ਐਰਰ ਨੂੰ ਫਿਕਸ ਕਰਦੇ ਹਾਂ । ਆਪਣੇ ਪ੍ਰੋਗਰਾਮ ‘ਤੇ ਵਾਪਸ ਆਉਂਦੇ ਹਾਂ ।
03:42	ਇਸ ਨੂੰ ਮਿਟਾਓ; ਇਸ ਨੂੰ ਇੱਥੇ ਪੇਸਟ ਕਰੋ ।
03:47	‘Save’ ‘ਤੇ ਕਲਿਕ ਕਰੋ ਅਤੇ ‘ਟਰਮੀਨਲ’ ‘ਤੇ ਚਲਾਓ ।
03:52	ਅਪ ਐਰੋ ਕੀ ਦਬਾਓ । ਪਿਛਲੀ ਕਮਾਂਡ ਨੂੰ ਦੁਬਾਰਾ ਕਾਲ ਕਰੋ ।
03:57	ਐਂਟਰ ਦਬਾਓ । ਟਾਈਪ ਕਰੋ: ‘ਡਾਟ ਸਲੈਸ਼ auto’ ਐਂਟਰ ਦਬਾਓ ।
04:03	ਇਹ ਕੰਮ ਕਰ ਰਿਹਾ ਹੈ! ਆਉਟਪੁਟ ਜ਼ੀਰੋ ਹੈ ।
04:07	ਅਜਿਹਾ ਇਸ ਲਈ ਹੈ ਕਿਉਂਕਿ ਅਸੀਂ ‘I’ ਦੀ ਵੈਲਿਊ 0 ਤੋਂ ਇਨਿਸ਼ਿਅਲਾਇਜ ਕੀਤੀ ਹੈ ।
04:13	ਹੁਣ ‘static variable’ ਵੇਖਦੇ ਹਾਂ ।
04:16	ਹਾਲਾਂਕਿ ਅਸੀਂ ਪਿਛਲੇ ਟਿਊਟੋਰਿਅਲ ਵਿੱਚ ‘static variable’ ਦੇ ਬਾਰੇ ਵਿੱਚ ਪੜ੍ਹ ਚੁੱਕੇ ਹਾਂ । ਮੈਂ ਇੱਥੇ ਇਸਨੂੰ ਸੰਖੇਪ ਵਿੱਚ ਸਮਝਾਉਂਗਾ ।
04:24	‘static’ ਵੈਰੀਏਬਲਸ ‘ਜ਼ੀਰੋ’ ਤੋਂ ਇਨਿਸ਼ਿਅਲਾਇਜ ਹੁੰਦੇ ਹਨ ।
04:28	‘ਬਲਾਕ’ ਤੋਂ ਪ੍ਰੋਗਰਾਮ ਕੰਟਰੋਲ ਐਗਜਿਟ ਹੋਣ ਦੇ ਬਾਅਦ ਵੀ ਇਹ ਨਸ਼ਟ ਨਹੀਂ ਹੁੰਦੇ ਹਨ ।
04:35	‘ਵੈਰੀਏਬਲ’ ਦੀ ਵੈਲਿਊ ਵੱਖ-ਵੱਖ ਫੰਕਸ਼ਨ ਕਾਲਸ ਦੇ ਵਿੱਚ ਸਥਾਈ ਰਹਿੰਦੀ ਹੈ ।
04:41	ਸਟੋਰੇਜ ਸਪੇਸ ‘CPU ਮੈਮੋਰੀ’ ਹੈ ।
04:45	ਹੁਣ ਇੱਕ ਉਦਾਹਰਣ ਵੇਖਦੇ ਹਾਂ । ਮੈਂ ਉਹ ਸਮਾਨ ਕੋਡ ਫਾਇਲ ਐਡਿਟ ਕਰਾਂਗਾ ।
04:51	ਆਪਣੇ ਪ੍ਰੋਗਰਾਮ ‘ਤੇ ਵਾਪਸ ਆਉਂਦੇ ਹਾਂ ।
04:54	ਇੱਕੋ-ਸਮੇਂ ‘Ctrl + Shft + S’ ਕੀ ਦਬਾਓ ।
05:01	ਹੁਣ ਮੈਂ ਫਾਇਲ ਦਾ ਨਾਮ static ਕਰਾਂਗਾ । Save‘ਤੇ ਕਲਿਕ ਕਰਾਂਗਾ ।
05:10	ਹੁਣ, ਮੈਂ ‘variable I’ ਦੇ ਇਨਿਸ਼ਿਅਲਾਇਜੇਸ਼ਨ ਨੂੰ ਬਦਲਕੇ ‘static int i equals to zero’ ਕਰਾਂਗਾ । Save ‘ਤੇ ਕਲਿਕ ਕਰਾਂਗਾ ।
05:23	ਹੁਣ ਵੇਖਦੇ ਹਾਂ ਕਿ ਕੀ ਹੁੰਦਾ ਹੈ । ਟਰਮੀਨਲ ‘ਤੇ ਫਾਇਲ ਨੂੰ ਚਲਾਉਂਦੇ ਹਾਂ ।
05:30	ਟਾਈਪ ਕਰੋ: ‘gcc space static.c space hyphen o space stat’.ਐਂਟਰ ਦਬਾਓ ।
05:41	ਟਾਈਪ ਕਰੋ ‘ਡਾਟ ਸਲੈਸ਼ stat’.ਐਂਟਰ ਦਬਾਓ ।
05:46	ਆਉਟਪੁਟ ਹੇਠ ਦਿੱਤੇ ਦੀ ਤਰ੍ਹਾਂ ਦਿਸਦੀ ਹੈ: 0, 1, 2, 3
05:51	ਅਜਿਹਾ ਇਸਲਈ ਹੈ ਕਿਉਂਕਿ ‘static variables’ ‘global variables’ ਹਨ ।
05:56	‘static variable’ ਦਾ ਸਕੋਪ ਫੰਕਸ਼ਨ ਦੇ ਲਈ ਲੋਕਲ ਹੈ ਜਿਸ ਵਿੱਚ ਉਹ ਪਰਿਭਾਸ਼ਿਤ ਹੈ ।
06:03	ਇਹ ‘ਫੰਕਸ਼ਨ ਕਾਲਸ’ ਦੇ ਵਿੱਚ ਆਪਣੀ ਵੈਲਿਊ ਨੂੰ ਨਹੀਂ ਗੁਆਉਂਦੇ ਹਨ ।
06:08	ਹੁਣ ‘extern keyword’ ਦੇ ਬਾਰੇ ਵਿੱਚ ਸਿੱਖਦੇ ਹਾਂ ।
06:12	‘extern variable’ ਦਾ ਸਕੋਪ ਪੂਰੇ ਮੇਨ ਪ੍ਰੋਗਰਾਮ ਵਿੱਚ ਹੈ ।
06:17	‘extern variable’ ਦੀ ਪਰਿਭਾਸ਼ਾ C ਪ੍ਰੋਗਰਾਮ ਵਿੱਚ ਕਿਤੇ ਵੀ ਹੋ ਸਕਦੀ ਹੈ ।
06:23	ਡਿਫਾਲਟ ਰੂਪ ਤੋਂ, extern variables ਜ਼ੀਰੋ ਤੋਂ ਇਨਿਸ਼ਿਅਲਾਇਜ ਹੁੰਦੇ ਹਨ ।
06:28	ਇਹ ਪ੍ਰੋਗਰਾਮ ਵਿੱਚ ਸਾਰੇ ਫੰਕਸ਼ਨਸ ਨਾਲ ਐਕਸੈੱਸ ਕੀਤੇ ਜਾ ਸਕਦੇ ਹਨ ।
06:33	ਇਹ ‘CPU memory’ ਵਿੱਚ ਇੱਕਠੇ ਹੁੰਦੇ ਹਨ ।
06:36	ਹੁਣ ਇੱਕ ਉਦਾਹਰਣ ਵੇਖਦੇ ਹਾਂ ।
06:38	ਮੇਰੇ ਕੋਲ ਇੱਕ ਕੋਡ ਫਾਇਲ ਹੈ; ਹੁਣ ਇਸ ਨੂੰ ਵੇਖਦੇ ਹਾਂ ।
06:42	ਨੋਟ ਕਰੋ ਕਿ ਸਾਡੀ ਫਾਇਲ ਦਾ ਨਾਮ ‘extern.c’ ਹੈ ।
06:47	ਮੈਂ ‘ਇੰਟੀਜਰ ਵੈਰੀਏਬਲ x’ ਨਾਂ ਵਾਲੇ ਇੱਕ ਵੈਰੀਏਬਲ ਨੂੰ ‘10’ ਤੋਂ ਇਨਿਸ਼ਿਅਲਾਇਜ ਕੀਤਾ ਹੈ ।
06:54	ਇਹ ਮੇਨ ਫੰਕਸ਼ਨ ਹੈ । ਮੇਨ ਫੰਕਸ਼ਨ ਵਿੱਚ ਮੈਂ ਇੱਕ ‘extern integer variable y’ ਐਲਾਨ ਕੀਤਾ ਹੈ ।
07:03	‘printf’ ਸਟੇਟਮੈਂਟ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਅਸੀਂ ‘x’ ਅਤੇ ‘y’ ਦੀਆਂ ਵੈਲਿਊਜ਼ ਨੂੰ ਦਿਖਾਵਾਂਗੇ । ਇਹ ‘return’ ਸਟੇਟਮੈਂਟ ਹੈ ।
07:12	ਮੇਨ ਫੰਕਸ਼ਨ ਦੇ ਬੰਦ ਹੋਣ ਦੇ ਬਾਅਦ ਅਸੀਂ ‘y’ ਨੂੰ ‘50’ ਤੋਂ ਇਨਿਸ਼ਿਅਲਾਇਜ ਕਰਾਂਗੇ ।
07:18	ਹੁਣ ‘ਟਰਮੀਨਲ’ ਖੋਲ੍ਹਦੇ ਹਾਂ ਅਤੇ ਵੇਖਦੇ ਹਾਂ ਕਿ ਆਉਟਪੁਟ ਕੀ ਹੋਵੇਗੀ ।
07:24	ਟਾਈਪ ਕਰੋ: ‘gcc space extern.c space hyphen o space ext.’ਐਂਟਰ ਦਬਾਓ ।
07:35	ਟਾਈਪ ਕਰੋ: ‘ਡਾਟ ਸਲੈਸ਼ ext.’ਐਂਟਰ ਦਬਾਓ ।
07:40	ਆਉਟਪੁਟ ਹੇਠ ਦਿੱਤੇ ਦੀ ਤਰ੍ਹਾਂ ਦਿਖਾਈ ਦੇਵੇਗੀ: ‘The value of x is 10’ ‘The value of y is 50’
07:48	ਜਿਵੇਂ ਕਿ ਅਸੀਂ ਪੜ੍ਹਿਆ ਹੈ ‘extern keyword’ ਦੀ ਵੈਲਿਊ ਮੇਨ ਪ੍ਰੋਗਰਾਮ ਵਿੱਚ ਸ਼ੁਰੂ ਤੋਂ ਅਖੀਰ ਤੱਕ ਹੁੰਦੀ ਹੈ ।
07:55	ਇਸ ਪ੍ਰੋਗਰਾਮ ਵਿੱਚ ਕਿਤੇ ਵੀ ਇਸ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰ ਸਕਦੇ ਹਾਂ ।
07:59	ਦੋਵੇਂ ਸਟੇਟਮੈਂਟਸ ਤਸਦੀਕ ਹੁੰਦੀਆਂ ਹਨ ।
08:02	ਹੁਣ ‘register keyword’ ‘ਤੇ ਜਾਂਦੇ ਹਾਂ ।
08:06	Register ਵੈਰੀਏਬਲਸ ਨਾਰਮਲ ਵੈਰੀਏਬਲਸ ਤੋਂ ਜ਼ਿਆਦਾ ਤੇਜ਼ੀ ਨਾਲ ਐਕਸੈੱਸ ਕੀਤੇ ਜਾਣਗੇ ।
08:13	ਇਹ ‘main memory’ ਦੇ ਬਜਾਏ ‘register memory’ ਵਿੱਚ ਇੱਕਠੇ ਹੁੰਦੇ ਹਨ ।
08:19	ਵੈਰੀਏਬਲਸ ਦੀ ਸੀਮਿਤ ਗਿਣਤੀ ਵਰਤੀ ਜਾ ਸਕਦੀ ਹੈ ਹਾਲਾਂਕਿ ਰਜਿਸਟਰ ਸਾਇਜ ਬਹੁਤ ਛੋਟਾ ਹੁੰਦਾ ਹੈ ।
08:25	16 bits, 32 bits ਜਾਂ 64 bits.
08:30	ਹੁਣ ਇੱਕ ਉਦਾਹਰਣ ਵੇਖਦੇ ਹਾਂ । ਮੇਰੇ ਕੋਲ ਇੱਕ ਕੋਡ ਫਾਇਲ ਹੈ । ਹੁਣ ਇਸਨੂੰ ਵੇਖਦੇ ਹਾਂ ।
08:37	ਨੋਟ ਕਰੋ ਕਿ ਫਾਇਲ ਦਾ ਨਾਮ ‘register.c’ ਹੈ ।
08:42	ਇੱਥੇ ਅਸੀਂ ‘register integer variable’ ਐਲਾਨ ਕੀਤਾ ਹੈ ।
08:47	ਇਹ ਵੈਰੀਏਬਲ ਸਿੱਧਾ ਰਜਿਸਟਰ ਮੈਮੋਰੀ ਵਿੱਚ ਇੱਕਠਾ ਹੋਵੇਗਾ ।
08:53	ਇਹ ‘for loop’ ਹੈ ਜੋ ‘1’ ਤੋਂ ‘5’ ਤੱਕ ‘I’ ਦੀ ਵੈਲਿਊ ਨੂੰ ਦਿਖਾਉਂਦਾ ਹੈ ।
08:59	ਇਹ ‘I’ ਦੀ ਵੈਲਿਊ ਦਿਖਾਵੇਗਾ ।
09:03	ਹੁਣ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਚਲਾਉਂਦੇ ਹਾਂ ਅਤੇ ਵੇਖਦੇ ਹਾਂ ।
09:07	ਟਰਮਿਨਲ ‘ਤੇ, ਟਾਈਪ ਕਰੋ: ‘gcc space register.c space hyphen o space register’
09:17	ਐਂਟਰ ਦਬਾਓ । ਟਾਈਪ ਕਰੋ: ‘ਡਾਟ ਸਲੈਸ਼ register’ ਐਂਟਰ ਦਬਾਓ ।
09:25	ਤੁਸੀਂ ਹੇਠ ਦਿੱਤਿਆਂ ਦੀ ਤਰ੍ਹਾਂ ਦਿਖਾਈ ਦੇ ਰਹੀ ਆਉਟਪੁਟ ਵੇਖ ਸਕਦੇ ਹੋ: ‘Values stored in register memory 1 2 3 4 5’
09:34	ਇਹ ਸਾਨੂੰ ਇਸ ਟਿਊਟੋਰਿਅਲ ਦੇ ਅਖੀਰ ਵਿੱਚ ਲੈ ਕੇ ਜਾਂਦਾ ਹੈ । ਇਸ ਦਾ ਸਾਰ ਕਰਦੇ ਹਾਂ ।
09:39	ਇਸ ਟਿਊਟੋਰਿਅਲ ਵਿੱਚ ਅਸੀਂ ਸਿੱਖਿਆ: ‘Storage class specifiers’ ‘auto keyword’ ‘static keyword’ ‘extern keyword’ ‘register keyword’
09:52	ਇੱਕ ਨਿਰਧਾਰਤ ਕੰਮ ਵਿੱਚ, ਪਹਿਲੇ ਪੰਜ ਨੰਬਰਸ ਦੇ ਜੋੜ ਨੂੰ ਪ੍ਰਿੰਟ ਕਰਨ ਦੇ ਲਈ ਇੱਕ ਪ੍ਰੋਗਰਾਮ ਲਿਖੋ ।
09:59	ਪ੍ਰੋਗਰਾਮ ਵਿੱਚ auto ਅਤੇ static ਦੋਵੇਂ ਕੀਵਰਡਸ ਨੂੰ ਐਲਾਨ ਕਰੋ ।
10:04	ਹੇਠਾਂ ਦਿੱਤੇ ਲਿੰਕ ‘ਤੇ ਉਪਲੱਬਧ ਵੀਡੀਓ ਨੂੰ ਵੇਖੋ ।
10:07	ਇਹ ਸਪੋਕਨ ਟਿਊਟੋਰਿਅਲ ਪ੍ਰੋਜੈਕਟ ਦਾ ਸਾਰ ਕਰਦਾ ਹੈ ।
10:11	ਚੰਗੀ ਬੈਂਡਵਿਡਥ ਨਾ ਮਿਲਣ ‘ਤੇ ਤੁਸੀਂ ਇਸਨੂੰ ਡਾਊਂਨਲੋਡ ਕਰਕੇ ਵੀ ਵੇਖ ਸਕਦੇ ਹੋ ।।
10:16	ਸਪੋਕਨ ਟਿਊਟੋਰਿਅਲ ਪ੍ਰੋਜੈਕਟ ਟੀਮ, ਸਪੋਕਨ ਟਿਊਟੋਰਿਅਲਸ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਵਰਕਸ਼ਾਪਾਂ ਚਲਾਉਂਦੀ ਹੈ
10:22	ਆਨਲਾਇਨ ਟੈਸਟ ਪਾਸ ਕਰਨ ਵਾਲਿਆ ਨੂੰ ਪ੍ਰਮਾਣ ਪੱਤਰ ਵੀ ਦਿੰਦੇ ਹਨ । ਜ਼ਿਆਦਾ ਜਾਣਕਾਰੀ ਦੇ ਲਈ, ਕ੍ਰਿਪਾ ਕਰਕੇ contact@spoken-tutorial.org ‘ਤੇ ਲਿਖੋ ।
10:33	ਸਪੋਕਨ ਟਿਊਟੋਰਿਅਲ ਪ੍ਰੋਜੈਕਟ ਟਾਕ-ਟੂ-ਅ ਟੀਚਰ ਪ੍ਰੋਜੈਕਟ ਦਾ ਹਿੱਸਾ ਹੈ ।
10:38	ਇਹ ਭਾਰਤ ਸਰਕਾਰ ਦੇ ਐਮਐਚਆਰਡੀ ਦੇ “ਆਈਸੀਟੀ ਵਲੋਂ ਰਾਸ਼ਟਰੀ ਸਾਖਰਤਾ ਮਿਸ਼ਨ” ਦੁਆਰਾ ਪ੍ਰਮਾਣਿਤ ਹੈ ।
10:45	ਇਸ ‘ਤੇ ਜ਼ਿਆਦਾ ਜਾਣਕਾਰੀ ਹੇਠਾਂ ਦਿੱਤੇ ਲਿੰਕ ‘ਤੇ ਉਪਲੱਬਧ ਹੈ । http://spoken-tutorial.org/NMEICT-Intro
10:52	ਆਈ.ਆਈ.ਟੀ ਬੰਬੇ ਤੋਂ ਮੈਂ ਨਵਦੀਪ ਤੁਹਾਡੇ ਤੋਂ ਇਜਾਜ਼ਤ ਲੈਂਦਾ ਹਾਂ । ਸਾਡੇ ਨਾਲ ਜੁੜਣ ਦੇ ਲਈ ਧੰਨਵਾਦ ।	}

Contributors and Content Editors

Navdeep.dav