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

From Script | Spoken-Tutorial
Revision as of 12:29, 5 February 2018 by Navdeep.dav (Talk | contribs)

(diff) ← Older revision | Latest revision (diff) | Newer revision → (diff)
Jump to: navigation, search
“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