සිරි ලාංකීය blog වංශ කතාවේ C සලකුණ
රයිට් c කිව්වම ඒක ඇවිල්ල පිස්සු පීකුදු පිරිසිදු පරසිදු බොක්ක කූල් වෙන programming language 1ක්- මේකේ තියෙන සමහර සීන් අදහගන්නත් බෑ- අතිවිශිස්ටයි - එහෙම කිහල බෑ මේක ඔයලට ඔන වෙනවමයි_
අනන් මනන් බයිල වැඩක් නෑ අපි c වල හොද පාට් 1ක් කරමු_ හොදයි කියල හිතෙන අය ඒ වගේම මේකෙන් වැඩක් ගත්ත අය කොමෙන්ටුවක් දාාන්න අමතක කරන්න එපා_ ඒක අපිට ලොකු ගැම්මක්(බයිල වැඩිද මන්දා) _ එහෙනම් ලොවෙත් නෑ ලොවි ගහෙත් නෑ ලෝවැඩ සගරාවෙත් නෑ වුනාට csinhalen.blogspot.com වල තියෙන අද පාඩමට යමු
අද මම කතා කරන්න යන්නේ C වල operators ගැන_ operators ගොඩක් තියෙනව වර්ග c වල_ ඒකෙන්මම අද කියන්න යන්නෙ bitwise Opearors ගැන.මේ operator වර්ග 5ක් තියෙනව
Bitwise operators
1. & And
2. | Or
3. ^ Exclusive or
4. ~ one's complement
5. << left Shift
6. >> right shift
අද මම මේකෙන් මුල් 4ම සිරාවට කරනව_ ඊලග 2 කරන්න කලින් පොඩි පොඩි සීන් 2 ,3ක් කරන්න තියේ _ සෝ අද පෝස්ටුවෙන් මුල් 4ම ඔයලට කියා දෙනව
මෙහෙමයි වැඩෙි ඔයල දන්නවද නම්බර් 1ක දුන්නම ඒකේ bit pattern 1 ගන්න, ඒක අවශ්ය වෙනව දැන්_ මොකද bitwise opearor කියන්නෙ ඒ bitpattern 1 මත කරන ගේමක්
මේ බලන්න 5 ඉලක්කම ගමු_ මේකේ බිට් පැට්න් 1 ගන්න 5 පහල රෑපේ තියෙන විදියට ගින්දර වගේ බෙදාගෙන යන්න_ 5 2න් බෙදුවම 2යි ඉතිරි 1යි_ ඒ 2 2න් බෙදුවම 1යි ඉතිරි 0යි
byte 1 කට bit 8 යි නේ_ අපි ඒ byte 1 කට මේ ගනිපු බිට් පැට්න් 1 දාමු
දැක්කද මම මේකේ X ටත් y ටත් bitpattern හදල තියෙනව_ තේරැනාද _ ඒක හරිම සරල easy වැඩක්
දැන් බහිමු opeartor number 1, And Opearor
And Opearor
අපි හිතමු X Y කියන්නෙ හරි හෝ වැරදි වෙන්න පුලුවන් අවස්තාවන් කියල
එහෙම අවස්තා 4ක් තියේ
X Y
හරි හරි
හරි වැරදි
වැරදි හරි
වැරදි වැරදි
and කියන වැඩේ හරි යන්න නම් x හරි යන්නත් ඕනෙ y හරි යන්නත් ඔනෙ
හරි කියන්නෙ 1
වැරදි කියන්නෙ 0
එතකොට x නුත් 1 වෙලා y නුත් 1 වෙනවනම් තමයි x&y කියන 1ත් 1 වෙන්නෙ_ වැඩේ පත්තු කරගත්ත නේද හරිනේ
මේ bitpatten opeartor වලදි අපි කොටුවෙන් කොටුව check කරල අවස්තාව ගන්නව
ඒ කියන්නෙ x වල අන්තිම කොටුව බලනවනම් y වලත් අන්තිම කොටුව තමයි check කරන්නෙ_ මේ විදියට කොටු set 1ම චැක් කරනව
අපි හිතම x=5, y=3 නම් x&y ඕනෙ කියල
and නම් 2 ම 1 වෙන්න ඕනෙ x&y නුත් 1 වෙන්න_ මේ රෑපෙ බැලුවම තේරෙනවනේ
දැන් මේ බිට් පැට්න් 1න් නිරෑපනය වෙන්නෙ 1 ඉලක්කම_ ගනනය කරල බලන්නකො ඕනෙනම්
ද
මේ උදාහරනෙ බලන්නකෝ__________________
#include <stdio.h>
int main(){
int x=5,y=3,z;
z= x & y;
printf("x & y : %d \n",z);
return 0;
}
or Operator |
X Y X|Y (X or Y)
1 1 1
1 0 1
0 1 1
0 0 0
or වලදි දෙකෙන් 1ක් හරි ගිහින් හරි; 2න් 2ම හරි හරියනවනම් හරි ඒක true ඒ කියන්නෙ 1
බලන්නකො රෑපේ
මේ උදාහරනෙ බලන්නකො
#include <stdio.h>
int main(){
int x=5,y=3,z;
z= x | y;
printf("x | y : %d \n",z);
return 0;
}
EXCLUSIVE OR ^
මේ කියන්නෙ 2න් 1ක් විතරමයි හරි යන්න ඕනෙ_ 2ම බෑ 1ක විතරමයි
මේකෙ අවුට් පුට් විදියට x^y ට ලැබෙන්නෙ 6_ මේකෙ බිට් පැට්න් 1 අනුව ගණනය කරාම ලැබෙන්නෙ 6
#include <stdio.h>
int main(){
int x=5,y=3,z;
z= x ^ y;
printf("x ^ y : %d \n",z);
return 0;
}
~ One's complement- unary
මේකෙන් එන්නෙ යම් සංඛ්යාවක් ගත්තොත් ඒකෙ bitpattern 1 සම්පූර්ණ අනික් පැත්ත_ සුලු දෙයක් නේද
දැන් මේකේ bitpattern 1 න් එන උත්තරෙ -6_
ඒක එන හැටි අවුල් වගෙද _ ඕනම රින සංඛ්යාවක bitpatten ගන්නෙ මෙහෙමයි
රින ගානෙ ධන අගය හිතන්න
-100 ඕනෙනම් +100 හිතන්න
1_ඒකෙ bitepattern ලියන්න
2_ඒ bitpattern 1 පරස්පරය ගන්න
3_අගට 1ක් add කරන්න
මෙහෙම
1_ 0 1 1 0 0 1 0 0
2_ 1 0 0 1 1 0 1 1
3_ 1
ans:- 1 0 0 1 1 1 0 0
ans එකටඇවිත් තියෙන්නෙ -100 බිට් පැට්න් 1_ තේරැනා නේද?
______________________අදට පාඩම අවසන් ඊලගට
bitwise operator වල shift 1 කරනව
ඊලගට අපි මේ විදියට ඉක්මනට ඉක්මනට කරගෙන ගිහින් pointers කියන c වල ඉතාම වැදගත් ඒ වගෙම ගොඩක් අයට අවුල් තියෙන lesson 1ට එනව එතකම් සමහර අයට මේක නම් මෙලෝ රහක් නෑ කියල හිතෙයි_ඉවසන්න අපි ඉක්මනටම pointers වලට බහිනවා_
වැඩේ වැදගත් නම් කොමෙන්ටුවක් දාන්න ඈ
ලොකු හයියක්
_____________________====++++++++++++++=========______________________
මුනගැසෙමු පිස්සු පීකුදු c පාඩමේ තවත් ගින්දර කොටසකින්
බුකියට එනවනම් ඔන්න
ගියා ඈ...................................................................
වැඩේ වැදගත් නම් කොමෙන්ටුවක් දාන්න ඈ
ලොකු හයියක්
_____________________====++++++++++++++=========______________________
මුනගැසෙමු පිස්සු පීකුදු c පාඩමේ තවත් ගින්දර කොටසකින්
මේක ලියන මම උදාර nana
බුකියට එනවනම් ඔන්න
ගියා ඈ...................................................................







3 comments:
සුපිරි මචන් හොදේ...........................................
උදාර සහෝගේ පොස්ටුවට මගෙන් පොඩි add එකක් :-p
1's compliment නැත්තම් ( sign - magnitude) ක්රමය data representation වල අසාර්ථක ක්රමයක්. එහෙම වෙන්න හේතුව තමයි ඒ ක්රමයේදී +0 ලෙසත් -0 ලෙසත් 0 ව කියන ඉලක්කම දක්වන්න bit pattern 2ක් වෙන් කරනවා. එක අවාසියක්. මොකද ඒ විදියට අපතේ යන්නේ අපිට data එකක් දක්වන්න පුළුවන් ක්රමයක්. අන්න ඒ නිසයි ඍන අගයන් දක්වන්න 2's compliment කියල ක්රමයක් හදාගත්තේ.. ඒවගේම 2's compliment එක ගන්න ඔයාට වඩා ලේසි ක්රමයක් තියනවා... ඔය උඩින් කියල තියෙන්නේ full theoretical ක්රමයක්. මේක පොඩි කෙටි ක්රමයක්
1 වෙනි පියවර -> අපිට ලියන්න තියෙන ඍන අගයේ ධන අගයේ binary bit pattern එක ලියාගන්නවා
උදා/ -100 නම් ලියන්න ඕනේ +100 යෙ bit pattern එක ලියාගත්තා
එතකොට එන්නේ 01100100
2 වෙනි පියවර -> ඔය ලියපු bit pattern එකේ පිටි පස්සේ ඉදන් ඉස්සරහට එනවා 1 ක් අහු වෙනකම්
01100100 නම් පිටිපස්සේ ඉදන් එනකොට මුලින්නම 1 ලැබෙන්නේ අන්තිමේ ඉදන් 3න් වෙනියට
ම වෙනි පියවර -> උඩින් අල්ලගත්තු 1 තියනවනේ ඊට ඉස්සරහ තියන 1කෙ ඒවා 0 කරනවා 0 ඒවා 1 කරනවා
දැන් අපි ගත්තේ 01100100 නේ අන්තිම ඉදන් 3න් වෙනි 1 කා තමා අපිට ඕනේ කරන 1ක ඒ 1කට ඉස්සරහ තියෙන්නේ 01100 කියන ටිකනේ ඒවා මාරු කරලා ලිව්වම 10011100
හරි නේද අර දුර ක්රමේට ගියත් මේ bit pattern එකම අවනේද??????
Post a Comment