Tuesday, January 7, 2025

C variables in සිංහල

 මේ ලිපියෙන් කතා කරන්නෙ variables ගැන ,

සරලව , අපි program එකක් ලියද්දි variables යොදා ගන්නේ Computer memory එකේ අපිට අවශ්‍ය data store ගැනීමට. පරිගනකෙයේ memory එක කිව්වම ඇවිල්ල විවිද type එකේ memory devices තියෙනවා .. 

ඔයාල දන්නවා HARDDISK එක , RAM එක ඊළඟට ප්‍රමාණයෙන් පොඩි හැබැයි ඉතාමත් වේගවත් වන, පරිගණකයේ processing unit එක අසලම තියෙන Registers මේ අතර වෙනවා.

දැන් අපි මුලින්ම බලමු variables යොදා ගන්නේ මොකටද කියල?
variables සරලව යොදා ගන්නේ , program එක run වන අවස්ථාවේ ඊට අවශ්‍ය data එකක් තියෙනවා නම්
එය පරිගණක main memory  එකේ store කරලා තියා ගන්න. මොකද program එක run වෙද්දී අපිට එම data
එක නැවත නැවත යොදා ගන්න සිද්ද වෙන්න පුළුවන්.

කෙටියෙන්ම කිව්වොත් RAM එකේ memory location එකක අපිට අවශ්‍ය data, store කරලා තියා ගන්නවා නැවත නැවත අවශ්‍ය වුනොත් කියල.
ඉතින් මොකක්ද මේ memory location කතාව, හිතන්න අපේ RAM එකේ logical view එක ඇවිල්ල මෙන්න මේ වගේ එකක් කියල.

 


ඉතින් මෙන්න මේකේ පේන විදියට, මේ තියෙන එක පොඩි කොටුවක් අපි RAM එකේ cell එකක් විදියට ගණන්
ගන්නවා ඒ වගේමයි මේ හැම cell එකකටම address එකක් තියෙනවා. අපිට address එක මතක තබා ගන්න බැරි නිසා එකට නමක් යොදා ගන්නවා , එක තමයි අපි variable  එකක් කියල හදුන්වන්නේ . 

දැන් බලමු අපි C-language එක බාවිතයෙන් variable එකක් create  කර ගන්න ආකාරය,
මේක කර ගන්න කලින් පොඩි දෙයක් දැන ගන්න ඕන, ඒ තමයි data types ...
මොකද RAM එක එක කියන්නේ storage device එකක් , මේ storage device එකේ data store කරන්න කලින් අපි programming language එක හරහා පැහැදිලි විදියට instructions ලබා දෙන්න ඕන කොහොමද ram එකේ ඉඩ බාවිතා ගන්නේ කියන එක ගැන.

ඉතින් මේක ඇවිල්ල හරිම සරල දෙයක් මොකද අපිට int  , float , char , double වගේ basic data  types යොදා ගන්න පුළුවන්. හැබැයි මතක තියා ගන්න ඕන මේවා pre-define  කරලා තිබ්බට සැලකිල්ලෙන් යොදා ගන්න ඕන කියන එක, එකට මේ data types ටිකට ආදාළ byte sizes ටික දැන ගෙන ඉන්න එක වටිනවා. 


ඉහත දක්වලා තියෙනව් රූපෙන් හොඳටම බලා ගන්න පුළුවන්, data types ටික සහ ඒවා memory එකේ ගන්න ඉඩ ප්‍රමාණය. උදාහරණය විදියට int data type එක byte 4ක ප්‍රමාණයක් memory  එකෙන් අල්ලගන්නවා ,ඒ වගේම short data type එකෙන් define කල data එකක් 2bytes ප්‍රමාණයක් ගන්නවා.

හරි දැන් තියරටිකල් පාර්ට් එක ඉවරයි, ඇත්තටම අපි ගොඩක් දෙයක් දේවල් කතා කලාට මේක implement කර ගන්න හරිම පහසුයි.
කරන්න තියෙන්නේ , ඔබට කැමති නමක් දාලා data එකට ගැලපෙන්න data type එක define කරලා දාන්න විතරයි
මේ ආකාරයට, 


int main(void) {
    int x = 10; <-- (data_type)(variable_name) = (value);
    return 0;
} 

හැබැයි මෙතැනදී දන ගන්න ඕන දේ තමයි ගැලපෙන data එකට ඊට අදාලා data size එක යොදා ගන්න එක, 

උදාහරණයක් විදියට ගත්තොත් , number එකක් යොදා ගත් අවස්ථාවක character එකක් define කරන්න යොදා ගන්න data type එකක් යොදා ගෙන බැහැ , ඒවගේමයි විශාල සංක්‍යාවක් පෙන්නන්න අවශ්‍ය වූ විට, short වගේ එකක් යොදා ගෙන බැහැ. 

දැන් මේ විදියට යනකොට කොහොමත් තේරෙනවා, දශම සංක්‍යාවක් (Floating-point number) එකක් යොදා ගන්න අවස්ථාවේ ඊට integer data types යොදා ගන්න බැරි බව.

දැන් අපි පිළිවෙලට හැම data type එකම යොදා ගෙන ලියලා print කර ගෙන බලමු


#include <stdio.h>
int main(void) {

  int first_number = 1000000000;
  short second_number = 23230;

  double third_number = 232.3333;
  float fourth_number = 322334343.34343;

  char first_character = 'A';

  printf("%d \n", first_number);
  printf("%d \n", second_number);
  printf("%f \n", third_number);
  printf("%f \n", fourth_number);

  printf("%c \n", first_character);

  return 0;
}

හරි දැන් data types ගැන ඉගෙන ගෙන , variables create කරලා එක display  කාර ගෙනත් අවසානයි. ඊළඟ කොටසින්  strings manipulations සහ data types වල ගැබුරට යමු. 


එහෙනම් ජයවේවා!

 

Thursday, January 18, 2024

Hello world in C Language


 

අද තමයි මේකේ දෙවැනි කොටස , ඔක්තෝබර් පළවෙනිදා පට්ට වැස්සක් අතරේ ලියන්නේ 🌧️🌧️ , කලින් ලිපියෙන් පොඩි හැදින්වීමක් සිදු කලේ , මොකද කාට හරි හිතෙන්න පුළුවන් මේ කාලෙට C වගේ පරිගණක බාශාවක් ඉගෙන ගන්න එකේ ප්‍රයෝජනයක් තියේද , ඒ කාලය වෙන වැඩකට allocate කලොත් නරකද වගේ දේවල් හිතෙන්න පුළුවන් , ඉතින් ඒ වගේ ගතියක් තිබ්බ නම් මීට පෙර ලිපිය කියෙව්වම මම හිතනවා අඩු වෙන්න ඇති කියල 😉

හරි දැන් අපි වැඩේට බහිමු , මම හිතනවා මේක කියවන ඔබ මොනවා හරි Linux based Os එකට හෝ WSL වලට වගේ මාරු වෙලා ඇති කියල , වැඩි කතා අනවශ්‍යයි අපි c වලින් සරල programme එකක් ලියල බලමු ,

#include <stdio.h>
int main(void){
printf("Hello world!");
return 0;
}
දැන් ඔයා ලග තියෙන මොනම හරි text editor (Sublimetext , VScode , Notepad ++ , vim , emacs ) එකක් Open කරලා උඩ දාල තියෙන code එක type කරන්න.
 
(මෙතැනදී IDE එකක් බාවිතා කරන්න පුළුවන් , හැබැයි code suggestions , build tools නැතුව අමුවෙන්ම code කරන එක , ඉගෙන ගන්න time එකේ හොදයි කියල හිතනවා .) ඊළඟට ලියා ගත්ත code එක .c කියන extension එකෙන් save කර ගන්න මොකද මේ අපි දැන් create කර ගන්නේ C File එකක් නිසා .
 
හරි , අපි සාර්ථක ලෙස code එක ලියා ගත්තට පස්සේ , ඊළඟට අපි ලියපු programme එක Compile කර ගන්න ඕන , ඉතින් මේ compile කරනවා කියන්නේ මොකක්ද ?? compile කරන්නේ මොකෙන්ද ?? compile කරද්දී මොකක්ද වෙන්නේ ?? මේ වගේ දේවල් ඔලුවට එන්න පුළුවන් , ඉතින් අපි ඒ දේවල් එකින් එක බලමු . 
 

අපි programme එකක් ලියද්දි අපේ පහසුවට ඉංග්‍රීසි බාෂාව තමයි බාවිතා කරන්නේ , ඉංග්‍රීසි බාෂවත් එක්ක විවිද ගණිතමය සංකේත සහ logical symbols නුත් බාවිතය ගන්නවා සාර්ථක programme එකක් ලියා අවසන් කර ගන්න .

හැබැයි මේ අපි බාවිතා කරන බාශාව පරිගනයකයට තේරෙනවද ?? මේ තියෙන hardware වලට තේරෙනවද ??

කොහෙත්ම තේරෙන්නේ නැහැ ..

පරිගණකය තේරෙන්නේ Binaries එහෙමත් නැත්නම 0 සහ 1 විතරයි . ඉතින් මේ අපිට තේරෙන බාෂාවෙන් ලිව්ව programme එක පරිගණකයට තේරෙන්න convert කිරීමේ කාර්ය පැවරිලා තියෙන්නේ Compiler එකට .

ඔබ නිකමට google කරලා බැලුවොත් මේ වෙනකොට විවද පරිගණක බාෂාවන් සදහා ඊට අදාලව තියෙන compilers බලා ගන්න පුළුවන් , එකම පරිගණක බාශාවට විවිද නම් වලින් compilers බාවිත වෙනවා දකින්නත් පුළුවන් , හැබැයි පරිගණක බාෂාවට අනුව මොන විදියේ architecture එකකට නිර්මාණය කල Compiler එකක් උනත් අවසානයේ සිදු කරන්නේ ඔයා ලියපු programme එක binaries වලට convert කරන එක තමයි.

හරි , දැන් අපිට compile කරනවා කියන එක තේරෙනවා , ඊළඟට අපි ලියපු code එක compile කරගෙන බලමු , ඉතින් මේකට අපි ගන්නේ gcc කියන compiler එක , මේක c language එකට වගේම c ++ වලටත් යොදා ගන්නවා .

මුලින්ම , ඔයාගේ පරිගණකයේ gcc තියේද කියල බලල එහෙම නැත්නම් install කර ගන්න ඕන .

 

 
gcc --version

මේක ගහල enter කලාට පස්සේ මෙහෙම display වෙනවා නම් , ඔයාගේ machine එකේ මේ වෙනකොට compiler එක තියෙනවා .

gcc (Ubuntu 11.4.0-1ubuntu1~22.04) 11.4.0
Copyright (C) 2021 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

 එහෙම නැත්නම්,

sudo apt update
sudo apt install gcc

මේ විදියට type කරලා install කර ගන්න පුළුවන් ..

ඉතින් මෙතනදී ඔයාලට තේරෙනවා මේකත් එක computer programme එකක් කියල , ඒ වගේම තමයි අපි compile කරන්න මේ programme එකට දෙන files steps කීපයක් හරහා ගිහිල්ල තමයි අවසානයේ පරිගණකයට තේරෙන executable binary file එකක් බවට convert වෙන්නේ . සරලවම මේ compilation process එක steps කීපෙකට තමයි සිද්ද වෙන්නේ . ( ඒක ගැන මම වෙනම ලිපියක් දාන්නම් )

gcc -o first first.c

දැන් මේක ගැන කතා කරා ඇති , compile කරමු , උඩ තියෙන විදියට type කරලා enter කරන්න , කිසිම case එකක් නැතුව compile වෙලා ඉවර වෙනවා කියන්නේ ඔයා පලවෙනි programme එක හරියට ලියල compile කරලා අවසානයි කියන එක . දැන් output එක විදියට first කියල binnary file එකක් create වෙලා ඇති . මේක open කරලා බැලුවම මේකේ symbols වගයක් පෙන්න පුළුවන් .

ඊළඟට මේක run කරලා බලමු මේ ආකාරයට,

 ./first


දැන් අපි සාර්ථක ලෙස , අපේ පලවෙනි programme එක ලියල run කරලා අවසානයි. අපි දැන් බලමු එකින් එකට code එකේ තියෙන syntax සහ ඒවගෙ තේරුම.

ඔයාල ට මුලින්ම බලා ගන්න පුළුවන් #include<stdio.h> කියන syntax එක ,

මේකේ මුලින්ම තියෙන්නේ # symbol එක , ඉතින් c language එකේ මේ symbol එක යොදා ගන්නේ programme එකට යම් කිසි pre-processing part එකක් එකතු කරන්න . දැනට pre-processing කියන්නේ , ඔයාලට මතක ඇති compilation process එක steps කීපෙකට වෙනවා කියල කලින් කිව්වනේ, අන්න ඒ එක අවස්තාවක තමයි pre-processing කියන සිද්දිය වෙන්නේ .

ඊළඟට අපි include යොදා ගත්ත , මොකද අපිට stdio කියන header file එක add කර ගන්න ඕන නිසා .

ඉතින් මේ මුල තියෙන #include එක use කරන්නේ අපිට code කරන් යද්දී , අපේ පහසුවට මොනවා හරි function එකක් call කලොත් අන්න ඒ function එකට අදාළ source code එක load කර ගැනීමක් තමයි මේ " #include " syntax එක බාවිතයෙන් වෙන්නේ , දැන් මෙතැනදී අපි stdio කියන header file එක බාවිතයට අර ගෙන තියෙනවා . එතකොට මොකක්ද මේ header file එකක් කියල කියන්නේ . මම කලින් සදහන් කල නේ , අපි code කරන යද්දී අපිට සමහර functions, macros වගේම data structures නුත් use කරන්න වෙනවා අපේ පහසුව උදෙසා.

(macros ගැන මම ඉස්සරහට කියනවා , data structures කියල කියන්නේ සරලව , අපිට programme එකේ data store කරන්න වගේම execute කරද්දීත් computer එකේ main memory එක ඕන වෙනවා නේ , ඉතින් මේ data structures use කරන්න memory එකේ data කාර්යක්ෂමව store කරන්න සහ access කර ගන්න-: මේවා ගැන ඉදිරියට සවිස්තර කතා කරනවා)

කාටහරි ප්‍රශ්නයක් එන්න පුළුවන් ඉතින් අපිට මේවා ලියන්න පුළුවන් නේ කියල , ඔව් ලියන්න පුළුවන් , හැබැයි එක අනවශ්‍ය විදියේ වෙලාව යන දෙයක් වෙන්න පුළුවන් enterprise level එකේදී , ඒ වගේම මේ libraries එහෙමත් නැත්නම් header files ඒ ඒ අදාළ engineers ල ලියල තියෙන්නේ ගොඩක් හිතල vulnerabilities උපරිම අඩු වෙන විදියට සහ උපරිම පලදායිතාවය ලබා ගන්න පුළුවන් අකාරයට . එහෙම එකේ අපි අයේ ලියන්න ඕන කමක් නැහැ (හැබැයි ඉගෙන කාලේ වෙලාව තියෙනවා නම් Wheel එක අලුතෙන් invent කලාට කමක් නෑ ).

ඉතින් දැන් අපේ code එකේ හැටියට , අපි stdio.h කියන header file එක add කර ගෙන තියෙන්නේ . දැන් අපි මේ standard input output header file එකේ තියෙන variables , functions prototypes බාවිත කරන්න පුළුවන් හිතේ හැටියට.

ඒ වගේමයි මේ stdio හෝ අනෙක් file එක වගේම system එකෙන් ලබා දෙන header files අපිට කියවා ගන්න පුළුවන් , MS code text-Editor එකේනම් right click කරලා header file එකේ text එක click කරලා goto definition දුන්නම බල ගන්න පුළුවන් අදාළ header file එකේ code එක , එහෙම නැත්නම් /usr/include directory එකට ගියාමත් අපිට OS එකෙන් ලබා දෙන header files ටික බල ගන්න පුළුවන් .

හරි දැන් ඊළඟට තියෙන්නේ main function එක , මෙතන අපිට අවශ්‍ය algorithms ලියනවා වගේම , අපිට අවශ්‍ය functions call කර ගන්න පුළුවන් . කලින් ඔයාල ලියපු programme එකෙත් printf(); function එක යොදා ගෙන තියෙනවා පේනවා. main function එකත් අනීත් functions වගේම තමයි, අපි function එකක් create කර ගන්නකොට යොදා ගන්න පිළිවෙලවල් මේකෙත් තියෙනවා,

<function එකේ return type එක> <function name එක> () ඇතුලේ අපිට data share කර ගන්න පුළුවන් වගේම , අපි මේවට කියනවා arguments කියල , උදාහරණෙ හැටියට නම් මෙතන void දල තියෙන්නේ , එතනට void නොදා ලිව්වත් කමක් නැහැ , හැබැයි එහෙම දාල ලියන එකෙන් compiler එක සතුටු වෙනවා . ඊළඟට return එක , මෙතන return එක 0 දීල තියෙන්නේ එකට හේතුව තමයි අපේ programme එක නිවැරදිව run උනා නම් return කරන්නේ 0 , 0 හැර වෙන මොනවා හරි return කරනවා නම් code එකේ කොතැනම හරි ප්‍රශ්නයක් තියෙන්නව . මේක බලන්න පුළුවන් , ඔයාලගේ terminal එකේ echo $? ට්ය්පේ කරලා , 0 return වෙනවා කියන්නේ programme එක successfully run වෙලා කියන එක.

#include <stdio.h>
int main()
{
    char* str;
    str = "GfG";
    *(str + 1) = 'n';
    return 0;
}

මේක fault එකක් තියෙන code එකක්. උදාහරණයක් විදියට මේක second.c කියල save කරලා , compile කරලා Run කරමු , මෙන්න Run කලාම segmentation fault එකක් වැටෙනවා.හැබැයි බැලූ බැල්මට code එකේ වැරැද්දකුත් නැහැ නේද ?? (Compiler එක ගොඩක් වෙලාවට warnings දෙන්න පුළුවන්.)(මේ error එක ගැනත් අපි ඉස්සරහට කතා කරමු), දැන් කලින් කිව්වා වගේ echo $? ගැහුවම return වෙන්නේ 0 නෙවේ , අන්න එකෙන් අදහසක් ගන්න පුළුවන් return 0 ගැන .

අදට මේ ලිපියෙන් මෙපමණයි ඉතින් , ඊළඟ එකෙන් සමුවෙමු ! ජයවේවා !

Tuesday, November 7, 2023

History of Hosts.txt File


 

පරිගණක ජාලයක් ගත්තම ඒ සියල්ල සම්බන්ද වෙලා තියෙන්නේ ip address වලින් .. නමක් එහෙමත් නැත්නම් domain name එකක් යොදා ගැනීමේ අවශ්‍යතාවයක් නැහැ , නමුත් අපේ පහසුවට අපි ඉලක්කම් මතක තියා ගැනීමේ අපහසු තාවය නිසා නම් බාවිතා කරනවා , google.com , facebook.com , amazon.com වගේ . පරිගණක ජාලකරණයේ ආරම්බක කාලයේ මිනිස්සු ip address ටික කොලේක print කරලා ඩෙස්ක් එකේ තමන් ලගින් අලව ගත්ත … ඔන්න ඔය කාලෙට පස්සේ , ඊට පසුව තමයි මෙය යොදා , කොට Domain name servers යොදා ගැනීමක් සිදු නැහැ ගන්නේ,සරලවම මේක phone book එකක් වගේ ip address එක පැත්තක සහ නම අනෙක් පැත්තේ තියෙනවා , සරලයි

IP Address Name
142.250.192.100 google.com

network administrator විසින් මේක distribute කරන අතර , එකිනෙකා තමන්ගේ local system එකට copy කර ගැනීමක් සිදු කල ගත යුතුයි, ඒවගේමයි system එකෙන් එකට මේ hosts file එක change වෙන්න පුළුවන් . අනිත් දේ , සරලවම අපිට මේ Hosts.txt file එක eddit කරන්න පුළුවන් notepad එක හරි තමන් කැමති Text Edittor එකක් උපයෝගී කර ගෙන .

Structs in C language / සිංහල

 


Structs ගැන ,

Structs , C language එකේ විශේෂ ස්ථානයක් ගන්නවා , එයට හේතුව , අපි දන්නවා අපිට programme එක තුල අවශ්‍ය දෙයක් computer memory එකේ තබා ගැනීමට අවශ්‍ය වූ විට සිදු කරන්නේ , variable එකක් create කරන එක. උදාහරණයක් විදියට ගත්තොත් ..

int x=20 , y=30; ආකාරයට . struct තුලින් කරන්නෙත් මේ හා සමාන ක්‍රියාවලියක් (ඒ කියන්නේ memory එකට acces කිරීමක්) . හැබැයි මෙහි වෙනස් කමක් දක්නට පුළුවන්, ඒ .. අපි variable එකක් create කරනකොට බාවිතා කරනවා data types කියලා ජාතියක් . int ,char ,short ,float ,long , double කියලා Data-types set එකක් අපි දැනටමත් දන්නවා , මේවට අපි කියනව pre-define data-types කියල, මොකද මේවා නිකන් standards වගේ එදා ඉදලා තිබ්බ දේවල් .

හැබැයි structs නිර්මාණය කරලා තියෙන්නේ , මේ Pre-define data types සමග බැදුණු varible කිහිපයක් එක් කරගෙන අපිට නව data type එකක් නිර්ම්මාණය කර ගතහැකි අකාරයටයි. අර සෙට් එක bundle කරලා එකක් නිර්මාණය කර ගැනීමක් තමයි සිද්ද වෙන්නේ , අන්න ඒ හේතුව නිසා අපි structs කියන්නේ User-define data type එකක් විදියට සලකනවා .

අපි උදාහරණයක් අරන් බලමු ,

#include <stdio.h>
int main(){
char *name; // pointer variable එකක් use කල එකට confused වෙන්න එපා , ඒ කොටසෙන් කියනවා 
char *district;
int student_count;
}

👆 ඉහත දක්වල තියෙන විදියට තමයි අපි normally code කරන්නේ 👆

හරි දැන් බලමු , අපි structs බාවිත කරමින් මේ සිදු කරන්නේ කොහොමද කියල ..

#include <stdio.h>

struct schools{
 char* name;
 char* district;
 int student_count;	
};

int main(){
	
}

මේක අපි ලියද්දි Global scope එකෙන් ලියන්නේ ( main එක උඩින් ලියන්නේ) , එම නිසා globaly available වෙනවා නිකන්ම. ඒවගේම තමයි මම කලින් කිව්වා වගේ ඔක්කොම bundle කරලා එකකට ගෙනාවට පස්සේ අලුතින් මේ නිර්මාණය වුනේ data type එකක් ( එය User-define data type එකක් කියලත් හදුන්වනවා ), ඉහත උදාහරණයට අනුව , මේකේ Data-type එක වෙන්නේ struct school කියන එක 🤠 // Data-type එක මොකක්ද කියලා ඇහුවොත් නිකන් school නෙවේ , struct school . 🤠

හරි දැන් Data-type එක නිර්මාණය කර ගෙන අවසානයි. දැන් තියෙන්නේ අපිට මේකෙන් ප්‍රයෝජනයක් ගන්න , අපිට මෙය main එකට call කර ගන්න වෙනවා , එහෙමත් නැත්නම් අපි මේ අවස්තාවට කියනවා struct එකක් declare කරනව කියලා , නැතිනම් initialize කරනවා යනුවෙනුත් හදුන්වන්න පුළුවන්. struct එක declare කරන්නේ මෙහෙමයි ,

#include <stdio.h>
struct schools{
   char* name;
   char* district;
   int student_count;
};
int main(){
	struct schools f_school;
return 0;
}

මේ ආකාරයට declare කර ගත්ත variable එක තවම initialize කළා කියන තැනට ඇවිල්ල නැහැ , එකට හේතුව අපි කිසිම Data එකක් දීල නැති එක , මෙන්න මේ ආකාරයට data අපි create කල variable එකට දෙමු … ( variable එක : f_school , data type එක : struct schools )

#include <stdio.h>
struct schools{
   char* name;
   char* district;
   int student_count;
};

int main(){
	struct schools f_school;
	f_school.name = "St.thomas College";
	f_school.district = "Matara";
	f_school.student_count = 6500;

    printf("%s \n",f_school.name);
    printf("%s \n",f_school.district);
    printf("%d \n",f_school.student_count);

    return 0;
}

output එක :

  • St.thomas College
  • Matara
  • 6500

ඒ වගේම අපිට පුළුවන් ඉහත අකාරයට initialize කර ගතපු data , පහත ඇති ආකාරයටත් වෙනස් කර ගැනීමට හැක

#include <stdio.h>
struct schools{
   char* name;
   char* district;
   int student_count;
};

int main(){
	struct schools f_school = {
        .name = "St.thomas College",
        .district = "Matara",
        .student_count = 6500
    };

    printf("%s \n",f_school.name);
    printf("%s \n",f_school.district);
    printf("%d \n",f_school.student_count);

    return 0;
}

අදට එපමණයි , ජයවේවා !🤍


 

Getting started in C / සිංහල

 


 

 “C” පාඩම් මාලාව පටන් ගන්න කලින් , මට නිකමට ලිපියක් ලියල දාන්න හිතුන , ඇයි ඇත්තටම මේ (C) පරිගණක බාශාවම ලිපි ටිකක් විදියට දාන්න හිතුනේ කියන එක ගැන. මේකෙදි අපිට C වල අතීත කතාව නොකිය ඉන්නම බැහැ , මොකද සරලවම C language එක බාවිතයට් ගෙන තමයි අද අපි බාවිතා කරන Operating Systems , ඒ වගේම device drivers , network හා සම්බන්ද applications , Embedded Systems සහ Databases වැනි බොහොමයක් ලියල තියෙන්නේ . ඉතින් 1972 දී , Dennis Richie මහතා Bell labs සමග වැඩ කරන කාලේ තමයි C language එක නිර්මාණය කරන්නේ , මෙතැනදී කියන්න ඕන අපි දැනට බාවිතා කරන technology හා සම්බන්ද දේවල් බොහොමයකට ආරම්බය වෙලා තියෙන්නේ bell labs සහ එහි සිටිය set එකේ පරිශ්‍රමය මත 🧙‍♂️ .. හරි දැනට දල අදහසක් තියෙනවා නේ අපි මේ code කරන්න බාවිත කරන බාශාව ගැන .. ! ඒවගේම දෙයක් තියෙනවා C බාෂාව තවත් විශේෂ වෙන , ඒ තමයි C වලට හැකියාව පවතිනවා Directly memory එක Access කරන්න , මේ දේ නිසා අපිට Data structures ලියද්දි සහ අලුත් ඒවා නිර්මාණය කරද්දී වටිනවා .. අපි අනිවාර්යෙන්ම මේ සම්බන්දව Pointers ගැන කතා කරනකොට , කතාකරමු .

 

දැන් code කරන්න වෙලාව හරි , මේකට අපිට CodeBLocks වගේ IDE එකක් යොදා ගන්න පුළුවන් , නැත්නම් හොදම විදිය කියල මම හිතන්නේ Old School විදියට text editor එකේ type කරලා compiler එකක් use කර ගෙන compile කර ගන්න එක . ( ඇත්තටම text editor එක බාවිත කරලා ඉගෙන ගන්න වෙලාවේ code කරන එක මම පුද්ගලිකව හිතනවා හොදයි කියල , under the hood වෙන දේවල් ඉගෙන ගන්න පුළුවන් මේ විදියෙන් , හැබැයි ලොකු systems මේ විදියට ලියන්නේ නැහැ ) , අනෙක් දේ තමයි Operating system එක , අපිට කැමති එකක ලියන්න පුළුවන් , හැබැයි Windows / Mac වලට වඩා මේක ඉගෙන ගන්න වේලාවෙ මොනවා හරි Linux/Unix based OS එකක ලියන එක වටිනවා , එකට හේතුව තමයි windows සහ Mac වල restrictions වැඩි , ඒ වගේම අපිට c එක්ක ඉදිරියට වැඩ කරද්දී සමහර system calls එහෙම programme ඇතුලේ call කරන්න වෙනවා , අන්න එනත්නදී ගැටළු එන්න පුළුවන් . ( මෙතැනදී OS එක විදියට Ubuntu බාවිතා කරනවානම් හොදයි , මොකද එක්තරා විදියකට පහසුයි බාවිතා කරන්නත් 😉) .(Ubuntu , Virtual machine එකක install කරන අකාරය මෙතනින් බලන්න )

හරි දැන් අපි දැන් C වල අතීත විත්ති ටිකකුත් දැන ගෙන , ගැලපෙන Os එකකුත් දාගෙන ඉන්න අතරේ, ඊළඟට මේ වැඩේට අවශ්‍ය මොකක්ද කියන එක අපි බලන්න ඕන , ඔව් .. ඊළඟට ඕන compiler එකක් , compiler එක කියන්නෙත් එක්තරා ආකාරයක application එකක්, මේක බාවිතයට ගන්නේ අපි High level language එකක් බාවිතා කරලා ලියන programme එක machine code එක බවට පරිවර්තනය කර ගන්න . ඉතින් මෙතැනදී අපි gcc compiler එක යොදා ගන්නවා අපේ c programme එක compile කර ගන්න (මෙතනදී ඔයාලට වෙන compiler එකක් යොදා ගන්නත් පුළුවන් , පොඩි research එකක් දාල කරන්න බලන්න ඒක).

ඉතින් , අදට මම මේ ලිපිය මෙතැනින් ඉවර කරනවා , ඊළඟ ලිපියේ අපි compiler එක install කරලා code කරන්න පටන් ගමු (Ubuntu වල gcc එකනම් inbuild එනවා , අපි clang වගේ එකකුත් test කරලා බලමු ) , එහෙනම්
ජයවේවා !

 

C variables in සිංහල