๐ C++ Programming
โ๏ธPART ONE
๐ Course Title: C++ Programming
Content :๐๐ป
๐ Introduction to Programming
๐ C++ Over View
๐ Facts
๐Introduction to Programming:
แฐแแ แแแแต แแ แจแแฌแ แตแแ แญแณแฝแ C++ แแ!
แ แ แแแฝแ แแญ แฅแแฐ Wikipedia, 700 programming languages แ แแญ แจแแฎแแซแแแ แแแแแฝ แ แแข
โ Programming แแ แแแต แแ?๐ค
แจแฐแ แแแฝ แ แแแ แฅแแฐแแแฃแฃแ แแ แจแฐแ แแ แจแฎแแแแฐแญ แแญ แแแแฃแฃแต (แจแฐแแซแฉ แตแแแ แแแตแ แต) แแฅแ แ แแณแต แแฐแแซแแชแแฝ แจแซแต แแณแต แแ แญ. แแญแแซแฑแ แฎแแแแฐแฎแฝ แจแแซแแแต ๐ 0101001 (binary numbers) แแ แฅแ แฐแแ แญแแแ แแจแณแต แ แแฝแแ ๐คทโโ!! แตแแแ แแแณแฝแแ แจแแซแแฃแฃแ high level programming แแแแแฝ แฐแแ แฉแข แ แแแแ แฅแ แแแณแ cout<<"hi" แฅแฌ แฅแ แ แฎแแแญแแฉ (compiler) แแฎแแแฉแฐแฌ แแฐ 101010 แแญแฎ แญแแจแแ แข ๐ค
๐C++ Overview
1โฃ C++ (แฒ แแแต แแแต) is general purpose programming language.
แแแตแ แจแชแฒแฎ แแ แฅแตแจ แฎแแแแฐแญ แฅแ แจแแฃแญแ แ แแแฌแฝแแฃ แจแแแ แแแแฃแ แชแซ แ แแฝ แฅแตแจ แจแฐแแณแฐแก แจAI แถแแตแแฎแฝ แแแแ แแตแซแต แซแตแฝแแ
2โฃ C++ is Object Oriented
แญแ แ programming แแตแฅ แฅแ แ แ แฃแ แแณแ Concept แแ (แจแแฌแ แแ) แแฐแแต แ แฐแแ แฅแแซแแแข
แแ แ แ แญแฉ แแแฅแซแซแต แซแ แ (แแแณแ แแ)
OOP (Object Oriented programming) แแตแฅ แแแฎแฝแ แแญ แฅแแฐ แฅแแแฐแ Object แแ แจแแแตแแตแแ แข แฅแแ แแ แ C++ แแตแฅ แ แแต แตแ 20 แแชแแฝ แจแแแ แ แญแแตแ แแฅแแต แจแแแแญ แฎแต แแแแ แแแแ แแชแแฝ แจแฐแแซแฌ แฎแต แ แแ แแ! แ แ แ แแต "car" แแฃแ class แ แแแ แญ color แจแแฃแ variable , speed () แจแแฃแ function แ แแตแก แ แแจแแญ ef
class Car {
public :
public:
void speed();
string color;
}
แญแแแ class แแฅแ object(แซแ แ แแ แฎแต แจแ object แแชแแ แแ) แแ แแ แฝแแแแข
Car car1;
Car car2;
Car car20; ...... แฅแซแแฉ แแแต แแ
แแฐแแต แญแแฃแฝแแ แแ แ แฃแ แแณแ แแ ๐
3โฃ C++ is case sensitive !
แแแตแ แ แแแ แแแตแจแณแต....
แ C++ แแตแฅ "MUHAMMED" , "muhammed", "MuHAmmeD" แถแตแฑแ แ แฃแ แจแฐแแซแฉ แแแต แแธแ specially Variable แ แญแแ แตแแ แแแข แตแแแ แ C++ แแตแฅ แ แแต Variable "name " แฅแฌ แขแแฅแญ..... แญแแ Var แแ แแ แแฝแแ แแญ แฅแแฐแแแฉแต แแแแ Small letter แแตแจแ แ แแฅแ๐๐พ ("name")
๐ แแ แ แแ แฅแแแต ๐
C++ แจแฐแแ แจแ แ Bjarne Stroustrup แจแฐแฃแ แแแฐแฅ แ 1979 แแ แญ แข
C++ แจแฐแแ แจแ "C" แจแแฃแ programming แแแข
แตแแแ "C" แจ "C++" แ แฃแต แแ....แฅแแฑแต ?๐ค๐
Content :๐๐ป
๐ Environment SetUp
๐ Basic Syntax
๐ Comments In C++
๐ Variable & Data Type
1โฃ Environment Setup
แซแ แ แซแซแ แฅแ แ แญแแต แแแแต แ แแข แจแแแแน Code::Block แถแแตแแญ แ แแซแ แ แแแ แแตแซแต แตแฝแแแนแข
แ แแ แแแญ แแฅแณแฝแ https://quincy-2005.software.informer.com/1.3/ DOWNLOAD Free 18.4 MB แแ แถแแตแแฏ
แ แแแ แ Quincy แแญแ แซแแจแณแนแตแ แ แแญแแต file แแแ แแตแฅ new แ แแแต แแญแ แ แแแ (Ctr+n) แ แแซแ แแญแแต แตแฝแแแฝแแข
2โฃ Hello World
โขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโข
แ แแแแชแซ แจ C++ แฎแถแฝ แจแแแแชแซแ แแตแแญ แแญ headers (แจแแญ แแแแ) tag แ แแธแ แข แญแ แ แแฎแแแญแแฉ (compiler C++ แ แฎแแแแฐแญ แแญ แฅแแตแฐแซ แจแแซแฐแญแ) แจแแแ แแแธแแ แจแฐแแซแฉ แแจแแแฝ แญแฐแ แแแข แแแณแ
#include <iostream>
แ แแ แฝ แฎแต แแตแฅ hashtag (#) แจแแซแแแญแฐแ แจcompiler preprocessorแแแฅแซแต แตแแ '#include ' แฐแแ แฎแแแญแแฉ '<iostream>' header แฅแตแซแซแตแต (to include ) แญแแแจแแแข
Note :
iostream is the header file which contains all the functions of program like cout, cin etc. and #include tells the preprocessor to include these header file in the program.
แ แแ แ แแฐแจแต แจแฐแแซแฉ Modues (library ) แแ แแ แตแแแแ แจแฎแณแฝแ แ แแต (header) แแญ แญแ แฝแ แฅแแ แแแ แแ!
แแแณแ C++ แแญ Maths แแแ แแ
#include <math.h> ๐คทโโ แฅแแ แแแแแข
โขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโข
๐แ แแแ แ main() แจแแฃแ function แแแ แซแตแแแแแ
แ แแแตแแ แฎแต แแตแฅ แฅแ แ แญแแต แจแฐแแซแฉ function แตแแแแตแ แ แฎแแแญแแฉ แแแ แตแซแแ แจ 'main()' function แญแแแซแแข
แแแณแ
#include<iostream>
int main()
{
//put your code here
}
โขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโข
๐Cout<<
แญแ Syntax แ แแตแก แจแแแ แแ แแแญ แ แฎแแแแฐแญ แแญ display แฅแแตแแ แซแฐแญแแ แข แแญแ แฎแแแญแแฉ แซแตแแฃแแแ process แ แญแ แฅแตแซแณแจแ แซแฐแญแแแข
แแแณแ
#include<iostream>
int main()
{
cout<< "Hello world "
}
แจแแญ แ แตแฐแแแฝแ แจแฐแแแจแณแฝแ cout<< แแแแ syntax แแฐ แแตแฅ แตแแต แ แตแญแ แจแแ แ แแต แฅแ แแ แญแแ แแแญแต ( " " )แ แแแแ แญแ แ แจแแแฉแต แแ (string) แแแแ แแแแแจแต แแแข แแฅแญ แแญแ แ แแต define แซแจแฉแต variable แฅแแ แ แแ แแแ
๐ Using namespace std
แญแ แจแแแแญแซ C++ version แแญ แ แแแ แจแ just แแฎแแแญแแฉ namespace แฅแแตแ แแ แแแแญ แ แแฅแแข
แตแแแ แแแ แฎแณแฝแ แ แแต(head) แแญ แญแ แฝแ แ แตแญแฑ
using namespace std;
แข(แญแ แ แ แแ แฒแแ แตแแแญแณแญ แจแณแฝ แฃแตแแแฅแฉแต แแถ แแญ แแแแจแต แตแฝแแแฝแแข)
แจแแ แ แแแ แ แแญแแฝแแ แดแญ แฅแแฐแญแแแ แฅแฑแ แแแตแจแแ แ แแตแณแฝแ file แแแแ แ แแแซแต แจแแซแ save as แแแแ แ แแซแ แแญแ แฎแแตแฎแ S (ctrl s) แ แแแซแต แจแแแฃแ แแแถ แแญ แตแแ แจแแแแฝแแตแ แจแฐแฃแฝแ แกแแ .cpp แฅแแฝแ แแฅแแฝแ แแ แญแ แ
Yourfilename.cpp
แญแ แแ แดแญ แ แตแญแแฝแ แ แตแ Quincy แแญ แจแแแน (Ctr + Alt + N ) แ แแตแจแ แแญแ แแ แจแแ run แ แแแซแต แ แตแแแฉแตแข แแญแ แจแแฎแฅ แฐแ แ แญแแต แ แญแจแ แ แ แฅแฑแ แแซแ แ แแฅแแข
โ๏ธPART ONE
๐ Course Title: C++ Programming
Content :๐๐ป
๐ Introduction to Programming
๐ C++ Over View
๐ Facts
๐Introduction to Programming:
แฐแแ แแแแต แแ แจแแฌแ แตแแ แญแณแฝแ C++ แแ!
แ แ แแแฝแ แแญ แฅแแฐ Wikipedia, 700 programming languages แ แแญ แจแแฎแแซแแแ แแแแแฝ แ แแข
โ Programming แแ แแแต แแ?๐ค
แจแฐแ แแแฝ แ แแแ แฅแแฐแแแฃแฃแ แแ แจแฐแ แแ แจแฎแแแแฐแญ แแญ แแแแฃแฃแต (แจแฐแแซแฉ แตแแแ แแแตแ แต) แแฅแ แ แแณแต แแฐแแซแแชแแฝ แจแซแต แแณแต แแ แญ. แแญแแซแฑแ แฎแแแแฐแฎแฝ แจแแซแแแต ๐ 0101001 (binary numbers) แแ แฅแ แฐแแ แญแแแ แแจแณแต แ แแฝแแ ๐คทโโ!! แตแแแ แแแณแฝแแ แจแแซแแฃแฃแ high level programming แแแแแฝ แฐแแ แฉแข แ แแแแ แฅแ แแแณแ cout<<"hi" แฅแฌ แฅแ แ แฎแแแญแแฉ (compiler) แแฎแแแฉแฐแฌ แแฐ 101010 แแญแฎ แญแแจแแ แข ๐ค
๐C++ Overview
1โฃ C++ (แฒ แแแต แแแต) is general purpose programming language.
แแแตแ แจแชแฒแฎ แแ แฅแตแจ แฎแแแแฐแญ แฅแ แจแแฃแญแ แ แแแฌแฝแแฃ แจแแแ แแแแฃแ แชแซ แ แแฝ แฅแตแจ แจแฐแแณแฐแก แจAI แถแแตแแฎแฝ แแแแ แแตแซแต แซแตแฝแแ
2โฃ C++ is Object Oriented
แญแ แ programming แแตแฅ แฅแ แ แ แฃแ แแณแ Concept แแ (แจแแฌแ แแ) แแฐแแต แ แฐแแ แฅแแซแแแข
แแ แ แ แญแฉ แแแฅแซแซแต แซแ แ (แแแณแ แแ)
OOP (Object Oriented programming) แแตแฅ แแแฎแฝแ แแญ แฅแแฐ แฅแแแฐแ Object แแ แจแแแตแแตแแ แข แฅแแ แแ แ C++ แแตแฅ แ แแต แตแ 20 แแชแแฝ แจแแแ แ แญแแตแ แแฅแแต แจแแแแญ แฎแต แแแแ แแแแ แแชแแฝ แจแฐแแซแฌ แฎแต แ แแ แแ! แ แ แ แแต "car" แแฃแ class แ แแแ แญ color แจแแฃแ variable , speed () แจแแฃแ function แ แแตแก แ แแจแแญ ef
class Car {
public :
public:
void speed();
string color;
}
แญแแแ class แแฅแ object(แซแ แ แแ แฎแต แจแ object แแชแแ แแ) แแ แแ แฝแแแแข
Car car1;
Car car2;
Car car20; ...... แฅแซแแฉ แแแต แแ
แแฐแแต แญแแฃแฝแแ แแ แ แฃแ แแณแ แแ ๐
3โฃ C++ is case sensitive !
แแแตแ แ แแแ แแแตแจแณแต....
แ C++ แแตแฅ "MUHAMMED" , "muhammed", "MuHAmmeD" แถแตแฑแ แ แฃแ แจแฐแแซแฉ แแแต แแธแ specially Variable แ แญแแ แตแแ แแแข แตแแแ แ C++ แแตแฅ แ แแต Variable "name " แฅแฌ แขแแฅแญ..... แญแแ Var แแ แแ แแฝแแ แแญ แฅแแฐแแแฉแต แแแแ Small letter แแตแจแ แ แแฅแ๐๐พ ("name")
๐ แแ แ แแ แฅแแแต ๐
C++ แจแฐแแ แจแ แ Bjarne Stroustrup แจแฐแฃแ แแแฐแฅ แ 1979 แแ แญ แข
C++ แจแฐแแ แจแ "C" แจแแฃแ programming แแแข
แตแแแ "C" แจ "C++" แ แฃแต แแ....แฅแแฑแต ?๐ค๐
Content :๐๐ป
๐ Environment SetUp
๐ Basic Syntax
๐ Comments In C++
๐ Variable & Data Type
1โฃ Environment Setup
แซแ แ แซแซแ แฅแ แ แญแแต แแแแต แ แแข แจแแแแน Code::Block แถแแตแแญ แ แแซแ แ แแแ แแตแซแต แตแฝแแแนแข
แ แแ แแแญ แแฅแณแฝแ https://quincy-2005.software.informer.com/1.3/ DOWNLOAD Free 18.4 MB แแ แถแแตแแฏ
แ แแแ แ Quincy แแญแ แซแแจแณแนแตแ แ แแญแแต file แแแ แแตแฅ new แ แแแต แแญแ แ แแแ (Ctr+n) แ แแซแ แแญแแต แตแฝแแแฝแแข
2โฃ Hello World
โขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโข
แ แแแแชแซ แจ C++ แฎแถแฝ แจแแแแชแซแ แแตแแญ แแญ headers (แจแแญ แแแแ) tag แ แแธแ แข แญแ แ แแฎแแแญแแฉ (compiler C++ แ แฎแแแแฐแญ แแญ แฅแแตแฐแซ แจแแซแฐแญแ) แจแแแ แแแธแแ แจแฐแแซแฉ แแจแแแฝ แญแฐแ แแแข แแแณแ
#include <iostream>
แ แแ แฝ แฎแต แแตแฅ hashtag (#) แจแแซแแแญแฐแ แจcompiler preprocessorแแแฅแซแต แตแแ '#include ' แฐแแ แฎแแแญแแฉ '<iostream>' header แฅแตแซแซแตแต (to include ) แญแแแจแแแข
Note :
iostream is the header file which contains all the functions of program like cout, cin etc. and #include tells the preprocessor to include these header file in the program.
แ แแ แ แแฐแจแต แจแฐแแซแฉ Modues (library ) แแ แแ แตแแแแ แจแฎแณแฝแ แ แแต (header) แแญ แญแ แฝแ แฅแแ แแแ แแ!
แแแณแ C++ แแญ Maths แแแ แแ
#include <math.h> ๐คทโโ แฅแแ แแแแแข
โขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโข
๐แ แแแ แ main() แจแแฃแ function แแแ แซแตแแแแแ
แ แแแตแแ แฎแต แแตแฅ แฅแ แ แญแแต แจแฐแแซแฉ function แตแแแแตแ แ แฎแแแญแแฉ แแแ แตแซแแ แจ 'main()' function แญแแแซแแข
แแแณแ
#include<iostream>
int main()
{
//put your code here
}
โขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโข
๐Cout<<
แญแ Syntax แ แแตแก แจแแแ แแ แแแญ แ แฎแแแแฐแญ แแญ display แฅแแตแแ แซแฐแญแแ แข แแญแ แฎแแแญแแฉ แซแตแแฃแแแ process แ แญแ แฅแตแซแณแจแ แซแฐแญแแแข
แแแณแ
#include<iostream>
int main()
{
cout<< "Hello world "
}
แจแแญ แ แตแฐแแแฝแ แจแฐแแแจแณแฝแ cout<< แแแแ syntax แแฐ แแตแฅ แตแแต แ แตแญแ แจแแ แ แแต แฅแ แแ แญแแ แแแญแต ( " " )แ แแแแ แญแ แ แจแแแฉแต แแ (string) แแแแ แแแแแจแต แแแข แแฅแญ แแญแ แ แแต define แซแจแฉแต variable แฅแแ แ แแ แแแ
๐ Using namespace std
แญแ แจแแแแญแซ C++ version แแญ แ แแแ แจแ just แแฎแแแญแแฉ namespace แฅแแตแ แแ แแแแญ แ แแฅแแข
แตแแแ แแแ แฎแณแฝแ แ แแต(head) แแญ แญแ แฝแ แ แตแญแฑ
using namespace std;
แข(แญแ แ แ แแ แฒแแ แตแแแญแณแญ แจแณแฝ แฃแตแแแฅแฉแต แแถ แแญ แแแแจแต แตแฝแแแฝแแข)
แจแแ แ แแแ แ แแญแแฝแแ แดแญ แฅแแฐแญแแแ แฅแฑแ แแแตแจแแ แ แแตแณแฝแ file แแแแ แ แแแซแต แจแแซแ save as แแแแ แ แแซแ แแญแ แฎแแตแฎแ S (ctrl s) แ แแแซแต แจแแแฃแ แแแถ แแญ แตแแ แจแแแแฝแแตแ แจแฐแฃแฝแ แกแแ .cpp แฅแแฝแ แแฅแแฝแ แแ แญแ แ
Yourfilename.cpp
แญแ แแ แดแญ แ แตแญแแฝแ แ แตแ Quincy แแญ แจแแแน (Ctr + Alt + N ) แ แแตแจแ แแญแ แแ แจแแ run แ แแแซแต แ แตแแแฉแตแข แแญแ แจแแฎแฅ แฐแ แ แญแแต แ แญแจแ แ แ แฅแฑแ แแซแ แ แแฅแแข
Software Informer
Quincy 2005. Get the software safely and easily.
Quincy is freeware open-source. It is a simple programming environment for C/C++ on Windows.
๐2
แแ แแแซ
#include<iostream>
using namespace std;
int main()
{
cout<< "Hello world "
}
Result (out put):
------------------------------
Hello world
---------------------------------
โขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโข
3โฃ Comments
แ programming แแตแฅ แฎแต แตแแ แ comment แแ แแ แ แฃแ แจแฐแแแฐแ แฅแฉ แแแต แแแข
แฎแแแญแแฉ แฎแณแฝแแ run แตแซแฐแญแ แ แฎแแแต แแแญ แจแฐแแแแ แญแฐแแแ....
แฎแณแฝแแ แฎแแแต แแตแจแ!
โขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโข
แฎแแแต แแตแจแ แแแต แฎแณแฝแแ แแแซแแก แฐแแฝ แตแ แฎแณแฝแ แแแ แแฅแซแญแซแ แแญแ แแจแแ แจแแแฐแฅแ แต แแแแต แแ:: แญแ แฎแแแต แจแฐแแแ แแแแ แจแแ แตแ แ แแแ แแตแฐแแแ แจแแแแแแ แแแฅแญแต แ แ แญแฉ แแแแ แ แแฅแ::
แฎแณแฝแแ แฎแแแต แแตแจแ แ แแแณแ แฎแณแฝแแ แแแซแแก แแแฝ แฐแแฝ แฅแป แณแญแแ แฅแแ แฐแแแฐแ แจแแแซแต แกแแ แฎแณแฝแแ แฅแแณแแจแณแ แฅแ แ แแแ แฅแแตแแตแณแแต แซแแแแ::
แแตแณแแป:-
แแฎแแซแแฝแแ แ แจแแตแแ แแ แฎแแแต แซแฐแจแแแ แแแญ แแฐแ แแแแฝ แ แญแณแญแ::
แจแแตแ แฅแแฐแแตแจแฑแต แฎแแแต แฅแแฐแฐแแ แจแแณแแแต แฎแฑแ แจแจแแณแฝแ แฅแป แแ::
แแณแฐแฅแซ:-
แจแฐแแซแฉ แฐแแฝ แฅแแฒแซแฉ แแญแแแ แแแฎแฝแ แ แฎแแแต แแตแฅ แแแ แ แญแแจแญแ::
แแแณแ: แแตแแญแถแฝ แแญแแ แญแฌแฒแต แซแญแต แแฅแฎแฝ แจแแณแฐแแตแ แจแแแ แญแแ แก
โขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโข
Example Comments
#include<iostream>
using namespace std;
int main()
{
// this is comment
cout<<"Hello world "
// put your comment here
}
Output
Hello World
โขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโข
แฅแตแซแแ แจแฐแแแแญแแแ แ แฐแจแแฝแ? แแคแฑแแ แ แแแฝแ? แฅแแณแ แฐแต แ แแฝแ แจแแแแญแซแฝแแ C++ แฎแต แฐแญแณแฝแแ๐ชแข แ แแแฅแแต แญแแแฝ แ แ แตแแ แญแถแฝ แตแแ แฐแจแณแฐแแ แแแ แแญแญ แฅแ แผแญ แ แแตแจแ แญแฐแฃแ แฉแแข แ แแ แญแแ แฅแตแญแแแแ แฐแแ แแฉแแข
Next On This Channel:
๐ Standard Input Output
๐ Variables
โค๏ธ If & else + functions
๐งก Data Structure stay tuned
แญแแฅแแ
#include<iostream>
using namespace std;
int main()
{
cout<< "Hello world "
}
Result (out put):
------------------------------
Hello world
---------------------------------
โขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโข
3โฃ Comments
แ programming แแตแฅ แฎแต แตแแ แ comment แแ แแ แ แฃแ แจแฐแแแฐแ แฅแฉ แแแต แแแข
แฎแแแญแแฉ แฎแณแฝแแ run แตแซแฐแญแ แ แฎแแแต แแแญ แจแฐแแแแ แญแฐแแแ....
แฎแณแฝแแ แฎแแแต แแตแจแ!
โขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโข
แฎแแแต แแตแจแ แแแต แฎแณแฝแแ แแแซแแก แฐแแฝ แตแ แฎแณแฝแ แแแ แแฅแซแญแซแ แแญแ แแจแแ แจแแแฐแฅแ แต แแแแต แแ:: แญแ แฎแแแต แจแฐแแแ แแแแ แจแแ แตแ แ แแแ แแตแฐแแแ แจแแแแแแ แแแฅแญแต แ แ แญแฉ แแแแ แ แแฅแ::
แฎแณแฝแแ แฎแแแต แแตแจแ แ แแแณแ แฎแณแฝแแ แแแซแแก แแแฝ แฐแแฝ แฅแป แณแญแแ แฅแแ แฐแแแฐแ แจแแแซแต แกแแ แฎแณแฝแแ แฅแแณแแจแณแ แฅแ แ แแแ แฅแแตแแตแณแแต แซแแแแ::
แแตแณแแป:-
แแฎแแซแแฝแแ แ แจแแตแแ แแ แฎแแแต แซแฐแจแแแ แแแญ แแฐแ แแแแฝ แ แญแณแญแ::
แจแแตแ แฅแแฐแแตแจแฑแต แฎแแแต แฅแแฐแฐแแ แจแแณแแแต แฎแฑแ แจแจแแณแฝแ แฅแป แแ::
แแณแฐแฅแซ:-
แจแฐแแซแฉ แฐแแฝ แฅแแฒแซแฉ แแญแแแ แแแฎแฝแ แ แฎแแแต แแตแฅ แแแ แ แญแแจแญแ::
แแแณแ: แแตแแญแถแฝ แแญแแ แญแฌแฒแต แซแญแต แแฅแฎแฝ แจแแณแฐแแตแ แจแแแ แญแแ แก
โขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโข
Example Comments
#include<iostream>
using namespace std;
int main()
{
// this is comment
cout<<"Hello world "
// put your comment here
}
Output
Hello World
โขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโขโข
แฅแตแซแแ แจแฐแแแแญแแแ แ แฐแจแแฝแ? แแคแฑแแ แ แแแฝแ? แฅแแณแ แฐแต แ แแฝแ แจแแแแญแซแฝแแ C++ แฎแต แฐแญแณแฝแแ๐ชแข แ แแแฅแแต แญแแแฝ แ แ แตแแ แญแถแฝ แตแแ แฐแจแณแฐแแ แแแ แแญแญ แฅแ แผแญ แ แแตแจแ แญแฐแฃแ แฉแแข แ แแ แญแแ แฅแตแญแแแแ แฐแแ แแฉแแข
Next On This Channel:
๐ Standard Input Output
๐ Variables
โค๏ธ If & else + functions
๐งก Data Structure stay tuned
แญแแฅแแ
โค1
What is C Programming Language?
แฒ (แจแฎแแแฉแฐแญ แแฎแแซแแ แแแ) แแแตแ แแ?
แฒ แจแฎแแแฐแญ แแฎแแซแแแ แแแ (แจแฐแแแฐ แ แ แซแฉ แฒ )
โ แจแฎแแแแตแญ แแฎแแซแแแ แแแ แฒแแ แ แชแแญแต แจแฒแตแฐแ แ แฐแช แฐแฅแ แ 1970แแน แแแแชแซ แแญ แ แฐแแต แชแบ (Dennis Ritchie) แฐแฐแญแถ แแจแ แข แจแแซ แแฒแ แ แ แฅแแแ แจแฎแแแฉแฐแญ แจแฒแตแฐแ แ แฐแช แฐแตแแแถ แ แ แแ แ แตแแต แจแแซแแแแ แแฎแแซแแแ แแแแแฝ แ แแฑ แแแข
โ แฒ แแแฝ แณแแ แแฎแแซแแแ แแแแแฝ แแฝแณ แแญ แณแแ แแ แฐแซแแถแแแข แ แฐแแญแ แฒ++ แแฒ แแปแปแซ แฐแฅแ แจแณแแฐ แแแ แแแข แจแฐแแ แแ แฅแแต แซแแ แฎแต แแแแฃแต แจแฐแแปแธ แแแ แแ แฒแณแแ แฃ แจแฒแตแฐแ แ แฐแช แถแแตแแฎแฝแ แแแตแซแต แจแฐแแแฐ แแแ แแ แณแ แแแฝ แถแแตแแฎแฝแแ แแแปแ แ แตแแต แซแแแแแแข
โ แจC แแแ
The language was formalized in 1988 by the American National Standard Institute (ANSI).
โ แจ UNIX OS แแ แ แแ แ แฒ แแฎแแซแแ แแแ แจแฐแปแ แแแข
โ Cross-platform แฒแแ แ แแแแแ แฆแแฌแฒแแ แฒแตแฐแ แแแตแ แ Windows, Unix/Linux and Mac แจแแฐแซ แจแแฎแแซแแแ แ แญแแต แแแข
โ แ แแ แแญ แซแ แจแแฎแแซแแแ แแแแแฝ แจแฒ แแฎแแซแแแ แแแแ แแ แ แแ แแญแ แ แจแแ แจC programming แจแ แปแปแ แ แญแฝ แแตแฐแแ แแแณแ C++แ แจแแฎ C# , Unix's C shell , D, Go , Java , JavaScript (including
transpilers), Julia, Limbo , LPC, Objective-C , Perl, PHP , Python , Rust , Swift , Verilog.
โ แตแแแ C แแฎแแซแแแ แ แแ แแญ แแ แจแ แแแฝแ แแฎแแซแแแ แแแแแฝ แแฐแจแต แจแฃแแ แจแแฎแแซแแแ แ แขแฎแต แฅแแฒแแแณ แซแฐแจแ แแแข
โ C แ American National Standard Institute (ANSI) แ แแแแฑแแ แจแแฎแแซแแแ แแตแแญแฑแ แซแแแ แต แ 1988 แแ แญแข
โ แฒ แแแแชแซ แแญ แแตแญแแต แแแต แฅแซ (system development) แ แฐแแญแ แฆแแฌแฒแแ แฒแตแฐแแ แแแซแซแแฑ แแฎแแซแแฝ แฅแ แ แแญ แแแ แกแก
โ แ แแต แจ C แแฎแแซแ แจ 3 แแตแแฎแฝ แฅแตแจ แแแฎแแฝ แแตแแฎแฝ แแปแ แญแปแแแข
แ C programing แจแฐแปแ แแฎแแซแ save แตแแฐแญแ
แจแฝแแ แแญแแฝแ แจแ แฅแซ แแญ แแปแ แ แแ แต ".c"; แแแณแ, hello.c แฅแแ แแตแแแฅ แญแแญแฅแแ แแแต แแแข
โ แ C แจแแฎแแซแ แแแ แแแตแซแต แจแแแ แ แฎแแแฐแญแ แแญ แจแแจแฐแแตแ แแแต แจแถแแตแแญ แแณแชแซแแฝ แซแตแแแแแณแ
1 Text Editor and
2 The C Compiler.
โ Text Editor แแฎแแซแแฝแแ แแแปแ แจแแ แ แแ แแ Examples Windows Notepad, OS Edit command, Brief, Epsilon, EMACS, and vim or vi.
โ A C program แจแแจแฐแแตแ แซแซแตแณแโ
โบ Preprocessor Commands
โบ Functions
โบ Variables
โบ Statements & Expressions
โบ Comments
โ แแแ แจC แแฎแแซแแแ แแแ แแฎแแซแ แฅแแฐแแจแฐแแ แ แ แญแคแแฝแแแแข
#include <stdio.h>
int main () {
/* my first program in C */
printf ( "Hello, World! \n" );
return 0 ;
}
โบ แจแแญ แซแแแ แแฎแแซแ แแแแซ
แจแแฎแแซแ แจแแแแชแซ แแตแแญ #include<stdio.h> แจแ แตแ-แแฎแฐแฐแญ แตแฅแแ แแ แฃ แญแ แ แแฐ แตแญแญแแ แแ แแแญ แจแแแฑ แ แแต แ C แฎแแแญแแญ แจ stdio.h แแญแแ แฅแแฒแซแซแตแต แญแแแจแแแกแก
โบ แแฃแฉ แแตแแญ int maim () แจแแฎแแซแ แ แแแแ แจแแแแญแ แต แแ แฐแแฃแญ แแ แกแก
โบ แจแแแฅแแ แแตแแญ แฎแแแต แฑแฃแ /*...*/ แ แฎแแแญแแฉ แฅแแณแญแแ แฅ /*แแตแฅ*/ แแแ แฅแแฝแ แฎแแแญแแฉ แ แซแแฅแ แแ แฅแแ แ แแฎแแซแ แแตแฅ แฐแจแแช แ แตแฐแซแจแถแฝแ แฅแแตแแจแแญ แญแจแณแแแกแก แตแแแ แฅแแฐแแ แซแ แแตแแฎแฝ แ แแฎแแซแ แแตแฅ แ แตแฐแซแจแถแฝ(Comment) แฐแฅแแ แญแ แซแ แกแก
โบ แจแแแฅแแ แแตแแญ printf (...) โHello worldโ แจแแ แแแฅแญแต แแฐ แฅแตแญแชแแฝแ แจแแซแแแ แแญแ แจแแซแณแจแ แแแกแก
โบ แจแแแฅแแ แแตแแญ return 0; แจmain () แฐแแฃแฉแ แซแ แแ แแ แฅแ values แแฐ 0 แญแแแณแแข
โ แ แฐแจแแชแ แแแแ แฅ
๐
https://www.tutorialspoint.com/cprogramming/index.htm
๐ https://en.m.wikipedia.org/wiki/C_(programming_language)
แ PDF แดแแแซแ แแญ แฅแญแแแแข
แ แตแฐแซแจแต แซแแฝแ แฎแแแต แแญ แแญแ แ
แแฐ แดแแแซแ แปแแ แแแแฃแต แจแแแแฝแ https://t.me/MuhammedComputerTechnology
แแฐ Ethiopian Digital Library แแแแฃแต แจแแแแฝแ https://t.me/EthiopiaDigitalLibrary
แฒ (แจแฎแแแฉแฐแญ แแฎแแซแแ แแแ) แแแตแ แแ?
แฒ แจแฎแแแฐแญ แแฎแแซแแแ แแแ (แจแฐแแแฐ แ แ แซแฉ แฒ )
โ แจแฎแแแแตแญ แแฎแแซแแแ แแแ แฒแแ แ แชแแญแต แจแฒแตแฐแ แ แฐแช แฐแฅแ แ 1970แแน แแแแชแซ แแญ แ แฐแแต แชแบ (Dennis Ritchie) แฐแฐแญแถ แแจแ แข แจแแซ แแฒแ แ แ แฅแแแ แจแฎแแแฉแฐแญ แจแฒแตแฐแ แ แฐแช แฐแตแแแถ แ แ แแ แ แตแแต แจแแซแแแแ แแฎแแซแแแ แแแแแฝ แ แแฑ แแแข
โ แฒ แแแฝ แณแแ แแฎแแซแแแ แแแแแฝ แแฝแณ แแญ แณแแ แแ แฐแซแแถแแแข แ แฐแแญแ แฒ++ แแฒ แแปแปแซ แฐแฅแ แจแณแแฐ แแแ แแแข แจแฐแแ แแ แฅแแต แซแแ แฎแต แแแแฃแต แจแฐแแปแธ แแแ แแ แฒแณแแ แฃ แจแฒแตแฐแ แ แฐแช แถแแตแแฎแฝแ แแแตแซแต แจแฐแแแฐ แแแ แแ แณแ แแแฝ แถแแตแแฎแฝแแ แแแปแ แ แตแแต แซแแแแแแข
โ แจC แแแ
The language was formalized in 1988 by the American National Standard Institute (ANSI).
โ แจ UNIX OS แแ แ แแ แ แฒ แแฎแแซแแ แแแ แจแฐแปแ แแแข
โ Cross-platform แฒแแ แ แแแแแ แฆแแฌแฒแแ แฒแตแฐแ แแแตแ แ Windows, Unix/Linux and Mac แจแแฐแซ แจแแฎแแซแแแ แ แญแแต แแแข
โ แ แแ แแญ แซแ แจแแฎแแซแแแ แแแแแฝ แจแฒ แแฎแแซแแแ แแแแ แแ แ แแ แแญแ แ แจแแ แจC programming แจแ แปแปแ แ แญแฝ แแตแฐแแ แแแณแ C++แ แจแแฎ C# , Unix's C shell , D, Go , Java , JavaScript (including
transpilers), Julia, Limbo , LPC, Objective-C , Perl, PHP , Python , Rust , Swift , Verilog.
โ แตแแแ C แแฎแแซแแแ แ แแ แแญ แแ แจแ แแแฝแ แแฎแแซแแแ แแแแแฝ แแฐแจแต แจแฃแแ แจแแฎแแซแแแ แ แขแฎแต แฅแแฒแแแณ แซแฐแจแ แแแข
โ C แ American National Standard Institute (ANSI) แ แแแแฑแแ แจแแฎแแซแแแ แแตแแญแฑแ แซแแแ แต แ 1988 แแ แญแข
โ แฒ แแแแชแซ แแญ แแตแญแแต แแแต แฅแซ (system development) แ แฐแแญแ แฆแแฌแฒแแ แฒแตแฐแแ แแแซแซแแฑ แแฎแแซแแฝ แฅแ แ แแญ แแแ แกแก
โ แ แแต แจ C แแฎแแซแ แจ 3 แแตแแฎแฝ แฅแตแจ แแแฎแแฝ แแตแแฎแฝ แแปแ แญแปแแแข
แ C programing แจแฐแปแ แแฎแแซแ save แตแแฐแญแ
แจแฝแแ แแญแแฝแ แจแ แฅแซ แแญ แแปแ แ แแ แต ".c"; แแแณแ, hello.c แฅแแ แแตแแแฅ แญแแญแฅแแ แแแต แแแข
โ แ C แจแแฎแแซแ แแแ แแแตแซแต แจแแแ แ แฎแแแฐแญแ แแญ แจแแจแฐแแตแ แแแต แจแถแแตแแญ แแณแชแซแแฝ แซแตแแแแแณแ
1 Text Editor and
2 The C Compiler.
โ Text Editor แแฎแแซแแฝแแ แแแปแ แจแแ แ แแ แแ Examples Windows Notepad, OS Edit command, Brief, Epsilon, EMACS, and vim or vi.
โ A C program แจแแจแฐแแตแ แซแซแตแณแโ
โบ Preprocessor Commands
โบ Functions
โบ Variables
โบ Statements & Expressions
โบ Comments
โ แแแ แจC แแฎแแซแแแ แแแ แแฎแแซแ แฅแแฐแแจแฐแแ แ แ แญแคแแฝแแแแข
#include <stdio.h>
int main () {
/* my first program in C */
printf ( "Hello, World! \n" );
return 0 ;
}
โบ แจแแญ แซแแแ แแฎแแซแ แแแแซ
แจแแฎแแซแ แจแแแแชแซ แแตแแญ #include<stdio.h> แจแ แตแ-แแฎแฐแฐแญ แตแฅแแ แแ แฃ แญแ แ แแฐ แตแญแญแแ แแ แแแญ แจแแแฑ แ แแต แ C แฎแแแญแแญ แจ stdio.h แแญแแ แฅแแฒแซแซแตแต แญแแแจแแแกแก
โบ แแฃแฉ แแตแแญ int maim () แจแแฎแแซแ แ แแแแ แจแแแแญแ แต แแ แฐแแฃแญ แแ แกแก
โบ แจแแแฅแแ แแตแแญ แฎแแแต แฑแฃแ /*...*/ แ แฎแแแญแแฉ แฅแแณแญแแ แฅ /*แแตแฅ*/ แแแ แฅแแฝแ แฎแแแญแแฉ แ แซแแฅแ แแ แฅแแ แ แแฎแแซแ แแตแฅ แฐแจแแช แ แตแฐแซแจแถแฝแ แฅแแตแแจแแญ แญแจแณแแแกแก แตแแแ แฅแแฐแแ แซแ แแตแแฎแฝ แ แแฎแแซแ แแตแฅ แ แตแฐแซแจแถแฝ(Comment) แฐแฅแแ แญแ แซแ แกแก
โบ แจแแแฅแแ แแตแแญ printf (...) โHello worldโ แจแแ แแแฅแญแต แแฐ แฅแตแญแชแแฝแ แจแแซแแแ แแญแ แจแแซแณแจแ แแแกแก
โบ แจแแแฅแแ แแตแแญ return 0; แจmain () แฐแแฃแฉแ แซแ แแ แแ แฅแ values แแฐ 0 แญแแแณแแข
โ แ แฐแจแแชแ แแแแ แฅ
๐
https://www.tutorialspoint.com/cprogramming/index.htm
๐ https://en.m.wikipedia.org/wiki/C_(programming_language)
แ PDF แดแแแซแ แแญ แฅแญแแแแข
แ แตแฐแซแจแต แซแแฝแ แฎแแแต แแญ แแญแ แ
แแฐ แดแแแซแ แปแแ แแแแฃแต แจแแแแฝแ https://t.me/MuhammedComputerTechnology
แแฐ Ethiopian Digital Library แแแแฃแต แจแแแแฝแ https://t.me/EthiopiaDigitalLibrary
Tutorialspoint
C Tutorial
C programming is a general-purpose, procedural, imperative computer programming language developed in 1972 by Dennis M. Ritchie at the Bell Telephone Laboratories to develop the UNIX operating system.
โ
#แแฎแแซแแแ แแแแ
แแแตแ แแ?
(what is programming language)?
แแแแญแซ programming language แจแแแ แแแญ แจแแจแณแฝแ แ แแต #แแฎแแซแ แแแตแ แแ(what is program) แจแแแแ แฅแแแแจแต #แแฎแแซแ แแแต แ แ แญแฉ แ แแตแ แแแญ แแแฅแซแต แแญแ แแคแต(output)แแแแแต แ แ แตแแซ แจแแแ แแธแ แแแฎแฝ แฅแฅแฅแฅ แแฎแแซแ แญแฃแแแข
แแแฃแ แซแญแต แแแแแต *805*....# call แฅแแฐแแแแ แแแต แแ แคแจแ แซแฅแแฃแแ แแฅแญ แตแญแญแ แจแแ Dear Customer, your prepaid account has been recharged succesfully แจแแ text แญแฐแญแ แแ แแแต แแแข แแฅแฉแ แแ แ แแณแตแแกแ แต แแ แแฐแแ แฅแตแจแฑ แ แแซแ แจแฎแจแฅ แแแญแต แแญแ แฐแแ แจแแตแแแต แจแซแญแต แแฅแญ แ แแต แฒแแต แขแแตแ แฒแตแฐแ แ แญแฐแซแแข
แแญ แฅแแฐแแ แแฎแแซแแฝแแ แตแญแญแ แจแแ แแคแต(output) แฅแแแแแ แซแแแ แฐแแ แฅแ แฐแต แจแแ แแคแต แฅแแแแแ แแญแ แตแ แฐแต แแ แญแแ แแแต แแแข
แแแฃแ แฆแจแณแฝ แซแแแ C++ แแฎแแซแ แฅแแแแจแต
#include <iostream>;
using namespace std;
int main( )
{
cout<<" Hello, World "<<endl;
return 0;
}
output : Hello, World
แญแ แจแแญ แ แฅแแแแแ แจแฐแแแ แแฃแ" Hello, World " แจแแแแ แ แแ screenu แแญ แซแฃแจแแ แฅแแแ แญแ แแ แแแญ แแฎแแซแ แฅแแแแแ แแแต แแแข แจแแญ แฃแแ แแฎแแซแ แแญ แจแแแแชแซแแน แแแต แแตแแฎแฝ แแแแแ แจ C++ code แ แแตแฐแฉแ แต แแ แจแแตแ แแแธแ แฒแแ แจแแณแตแแกแตแ แฎแต แฎแแแญแแซแนแ แฅแแฒแจแณแ แจแแจแฑ แแ แจแต แจแแแฃแธแ แแแฎแฝ แแธแแข
แจแแญ แซแแแ แแฎแแซแ run แ แแณแฐแญแแ แต แแ แต แฎแแแแฐแซแนแ แแญ HI ATC แจแแ out put แญแแฃแแนแแ cout<< ____ ; แฐแฅแ แจแแแฃ แแแแแ แ แญแแต data แแฎแแซแแ แจแญแณแนแ run แตแณแฐแญแ แฎแแแแฐแซแนแ แแญ แญแแฃแ แแแต แแ int main( ) แจแแแ แจแแณแตแแกแต แแแญ แ แแ integer แแแแ แแฎแแแญแแฉ แซแณแแแแ
The syntax for preprocessor directive statement is
#include <headerfilename.h>
The .h extension tells the compiler that the file is a header file. The preprocessor directive
statement instructs the compiler to bring all the contents of the header file to our program.
Some of the header files that we are going to use are:
iostream.h: - contains standard input and output functions.Some of the functions defined ( แฅแ แแแณแแแต แจแฐแ แแแแ แจheader type แแ แแแฝแ แแ แฅแ แแแณแ math.h แจแแฃแ แจแแฐแญ แ แญแแต แ แ แฅแ แแ แจแแแฐแซแ แแฎแแซแ แแญ Mathematical formula och like cosine, sine, tangent, quadratic equation...แแแฐ แฒแแฉ แญแ แแ แฅแแ แแแแ แแแณแ แซแแฉแแฐแญ แแตแซแต แฅแตแแแ # include <math.h> แจแแ แแแขแซ แแ แแ แญแแญแฃแนแแ
Here are:
Cin>>: is a standard input function that accepts input from the user. Syntax:
For single input
Cin>>var1; // var แแแต แแแแแ แจแแณแตแแกแต แแแญ แแแต แแ
For multiple inputs
Cin>>var1>>var2>>var3; // แจแแณแตแแงแธแ inputs
Cin will take value from the keyboard and store it in the memory. Thus the cin statement needs a variable that is a reserved memory place holder.
Cout<<: standard output function that displays its content to the Screen.Syntax:
For single output
Cout<<Var1;
For multiple outputs
Cout<<var1<<โ, โ<<var2<<โ and โ<<var3;
<<endl: standard output function that displays a new line character
โบ แแฎแแซแแแ แแแแ แแแตแ แแ แฆ
แแฎแแซแแแ แแแแ แแแต แจแซแก แจแแ แจแ แแแ แ แ แซแแ แแ แจแแแฝแแธแ แฝแฎแแซแแฝ แจแแซแฅแฐแณแตแญ แแแต แแแข
โ sorce code แฅแแจแแแแ แแฎแแซแ
โ machine language แฎแแแแฐแญ แจแแจแณแ แต แแแ แแแต แแแข
๐ syntax(แฃแญแแณแญแฅ)
แจแแญ แแแฅแแฅ แฅแแฐ แแจแญแฉแต แแฎแแซแแแ แแแแ แแแต แจแซแก แจแแ แจแ แแแ แ แ แ แแ แญแ แจแ แแแ แ แ แฃแญแแณแญแฅ(syntax)แญแฃแแแข
Like แ แแญแ แแญ แ แแ แ แฅแแแแแ แแญ แฐแแ แแซแแญ แฅแแฐแแแแ แแแต แแแข #แแแฃแ แญแ แ แแฎแแซแ แฅแแแแจแต แฅแแ แแญ แจแฐแแแ แฅแซแแณแแฑ แแแญ syntax แแ แจแต แซแฐแจแ แแแข
#include <iostream>
using namespace std;
int main( )
{
cout<<" hello world"<<endl;
return 0;
}
แแแฃแ แ แแตแ แ แจแแฐ แแแญ แ แแ แฅแแจแญแฅ แแ แแญแ แ แซแต แแฅแฅ แคแแฅแแแแแ แ แแต แแฅแฅ(full stop)&แ แแฎแแซแแแ แแแแ แฐแแ" ; " แฅแแ แแแแ แแแญ แแ แแแ แแฎแแซแแแ แแแแ แแแต แฃแญแแ C++ แจแแฎ แ แฅแแแน " ; "แญแ แแแแข
แฅแ #แแฎแแซแแแ แแแแ (แแแ) แญแ แ แซแ แ แซแแซแ แ แแแ แ แแ แแ แจแแฃแแตแ แฅแแฅแแต แ แ แแ แ แ แต แ แ แแแฝแ แแญ แฅแ แ แญแแต แฅแ แฅแ แ แซแแธแ แแฎแแซแแแ แแแแ แแฝ แ แ แจแแญแกแ แแซแจแ แ แแแแต แจแแ แแกแต แจแแจแฐแแต แแธแ
โ JS(javascript)
โ C
โ phyton
โ C++
โ Go(Go lang)
โ C#
โ Java
โ CSS
โ Php
โ html etc...
แแแฌ แฅแแ แแญ แญแฅแแ แ แแฃแญ แตแแฅแซแแณแแฑ แแฎแแซแแ แแแ แ แฅแแแต แฅแซแจแ แฅแแแณแแข
โโแผแญโปโปแญแฐแจแ แฅแ แแแ แจแแแแ
#แแแตแ #แฅแ แถแฝ แ แแ!
#แจแฐแแฉแตแ_แแตแฐแแญ #แซแแแตแ_แแณแแ #แฅแแ แแต แแ
แ แแ แจแดแแแซแ แปแแ
https://t.me/MuhammedComputerTechnology
แฅแฉ แฅแฉ แตแแฎแแแแฐแญแ แดแญแแแ แแจแแแฝ แฅแ แฅแแแถแฝ แญแแแแ แซแแแตแ แฅแแแต แซแณแตแแ
แ แดแแแซแ แปแแ แ แแแฃแต แฅแ แแจแแแฝแ แแแแต แตแฝแแแฝแแข
(what is programming language)?
แแแแญแซ programming language แจแแแ แแแญ แจแแจแณแฝแ แ แแต #แแฎแแซแ แแแตแ แแ(what is program) แจแแแแ แฅแแแแจแต #แแฎแแซแ แแแต แ แ แญแฉ แ แแตแ แแแญ แแแฅแซแต แแญแ แแคแต(output)แแแแแต แ แ แตแแซ แจแแแ แแธแ แแแฎแฝ แฅแฅแฅแฅ แแฎแแซแ แญแฃแแแข
แแแฃแ แซแญแต แแแแแต *805*....# call แฅแแฐแแแแ แแแต แแ แคแจแ แซแฅแแฃแแ แแฅแญ แตแญแญแ แจแแ Dear Customer, your prepaid account has been recharged succesfully แจแแ text แญแฐแญแ แแ แแแต แแแข แแฅแฉแ แแ แ แแณแตแแกแ แต แแ แแฐแแ แฅแตแจแฑ แ แแซแ แจแฎแจแฅ แแแญแต แแญแ แฐแแ แจแแตแแแต แจแซแญแต แแฅแญ แ แแต แฒแแต แขแแตแ แฒแตแฐแ แ แญแฐแซแแข
แแญ แฅแแฐแแ แแฎแแซแแฝแแ แตแญแญแ แจแแ แแคแต(output) แฅแแแแแ แซแแแ แฐแแ แฅแ แฐแต แจแแ แแคแต แฅแแแแแ แแญแ แตแ แฐแต แแ แญแแ แแแต แแแข
แแแฃแ แฆแจแณแฝ แซแแแ C++ แแฎแแซแ แฅแแแแจแต
#include <iostream>;
using namespace std;
int main( )
{
cout<<" Hello, World "<<endl;
return 0;
}
output : Hello, World
แญแ แจแแญ แ แฅแแแแแ แจแฐแแแ แแฃแ" Hello, World " แจแแแแ แ แแ screenu แแญ แซแฃแจแแ แฅแแแ แญแ แแ แแแญ แแฎแแซแ แฅแแแแแ แแแต แแแข แจแแญ แฃแแ แแฎแแซแ แแญ แจแแแแชแซแแน แแแต แแตแแฎแฝ แแแแแ แจ C++ code แ แแตแฐแฉแ แต แแ แจแแตแ แแแธแ แฒแแ แจแแณแตแแกแตแ แฎแต แฎแแแญแแซแนแ แฅแแฒแจแณแ แจแแจแฑ แแ แจแต แจแแแฃแธแ แแแฎแฝ แแธแแข
แจแแญ แซแแแ แแฎแแซแ run แ แแณแฐแญแแ แต แแ แต แฎแแแแฐแซแนแ แแญ HI ATC แจแแ out put แญแแฃแแนแแ cout<< ____ ; แฐแฅแ แจแแแฃ แแแแแ แ แญแแต data แแฎแแซแแ แจแญแณแนแ run แตแณแฐแญแ แฎแแแแฐแซแนแ แแญ แญแแฃแ แแแต แแ int main( ) แจแแแ แจแแณแตแแกแต แแแญ แ แแ integer แแแแ แแฎแแแญแแฉ แซแณแแแแ
The syntax for preprocessor directive statement is
#include <headerfilename.h>
The .h extension tells the compiler that the file is a header file. The preprocessor directive
statement instructs the compiler to bring all the contents of the header file to our program.
Some of the header files that we are going to use are:
iostream.h: - contains standard input and output functions.Some of the functions defined ( แฅแ แแแณแแแต แจแฐแ แแแแ แจheader type แแ แแแฝแ แแ แฅแ แแแณแ math.h แจแแฃแ แจแแฐแญ แ แญแแต แ แ แฅแ แแ แจแแแฐแซแ แแฎแแซแ แแญ Mathematical formula och like cosine, sine, tangent, quadratic equation...แแแฐ แฒแแฉ แญแ แแ แฅแแ แแแแ แแแณแ แซแแฉแแฐแญ แแตแซแต แฅแตแแแ # include <math.h> แจแแ แแแขแซ แแ แแ แญแแญแฃแนแแ
Here are:
Cin>>: is a standard input function that accepts input from the user. Syntax:
For single input
Cin>>var1; // var แแแต แแแแแ แจแแณแตแแกแต แแแญ แแแต แแ
For multiple inputs
Cin>>var1>>var2>>var3; // แจแแณแตแแงแธแ inputs
Cin will take value from the keyboard and store it in the memory. Thus the cin statement needs a variable that is a reserved memory place holder.
Cout<<: standard output function that displays its content to the Screen.Syntax:
For single output
Cout<<Var1;
For multiple outputs
Cout<<var1<<โ, โ<<var2<<โ and โ<<var3;
<<endl: standard output function that displays a new line character
โบ แแฎแแซแแแ แแแแ แแแตแ แแ แฆ
แแฎแแซแแแ แแแแ แแแต แจแซแก แจแแ แจแ แแแ แ แ แซแแ แแ แจแแแฝแแธแ แฝแฎแแซแแฝ แจแแซแฅแฐแณแตแญ แแแต แแแข
โ sorce code แฅแแจแแแแ แแฎแแซแ
โ machine language แฎแแแแฐแญ แจแแจแณแ แต แแแ แแแต แแแข
๐ syntax(แฃแญแแณแญแฅ)
แจแแญ แแแฅแแฅ แฅแแฐ แแจแญแฉแต แแฎแแซแแแ แแแแ แแแต แจแซแก แจแแ แจแ แแแ แ แ แ แแ แญแ แจแ แแแ แ แ แฃแญแแณแญแฅ(syntax)แญแฃแแแข
Like แ แแญแ แแญ แ แแ แ แฅแแแแแ แแญ แฐแแ แแซแแญ แฅแแฐแแแแ แแแต แแแข #แแแฃแ แญแ แ แแฎแแซแ แฅแแแแจแต แฅแแ แแญ แจแฐแแแ แฅแซแแณแแฑ แแแญ syntax แแ แจแต แซแฐแจแ แแแข
#include <iostream>
using namespace std;
int main( )
{
cout<<" hello world"<<endl;
return 0;
}
แแแฃแ แ แแตแ แ แจแแฐ แแแญ แ แแ แฅแแจแญแฅ แแ แแญแ แ แซแต แแฅแฅ แคแแฅแแแแแ แ แแต แแฅแฅ(full stop)&แ แแฎแแซแแแ แแแแ แฐแแ" ; " แฅแแ แแแแ แแแญ แแ แแแ แแฎแแซแแแ แแแแ แแแต แฃแญแแ C++ แจแแฎ แ แฅแแแน " ; "แญแ แแแแข
แฅแ #แแฎแแซแแแ แแแแ (แแแ) แญแ แ แซแ แ แซแแซแ แ แแแ แ แแ แแ แจแแฃแแตแ แฅแแฅแแต แ แ แแ แ แ แต แ แ แแแฝแ แแญ แฅแ แ แญแแต แฅแ แฅแ แ แซแแธแ แแฎแแซแแแ แแแแ แแฝ แ แ แจแแญแกแ แแซแจแ แ แแแแต แจแแ แแกแต แจแแจแฐแแต แแธแ
โ JS(javascript)
โ C
โ phyton
โ C++
โ Go(Go lang)
โ C#
โ Java
โ CSS
โ Php
โ html etc...
แแแฌ แฅแแ แแญ แญแฅแแ แ แแฃแญ แตแแฅแซแแณแแฑ แแฎแแซแแ แแแ แ แฅแแแต แฅแซแจแ แฅแแแณแแข
โโแผแญโปโปแญแฐแจแ แฅแ แแแ แจแแแแ
#แแแตแ #แฅแ แถแฝ แ แแ!
#แจแฐแแฉแตแ_แแตแฐแแญ #แซแแแตแ_แแณแแ #แฅแแ แแต แแ
แ แแ แจแดแแแซแ แปแแ
https://t.me/MuhammedComputerTechnology
แฅแฉ แฅแฉ แตแแฎแแแแฐแญแ แดแญแแแ แแจแแแฝ แฅแ แฅแแแถแฝ แญแแแแ แซแแแตแ แฅแแแต แซแณแตแแ
แ แดแแแซแ แปแแ แ แแแฃแต แฅแ แแจแแแฝแ แแแแต แตแฝแแแฝแแข
Telegram
Muhammed Computer Technology (MCT)
๐ดแ แตแซแป:-
โ แต.แ: 0929273364
โ แแฅแณแญแต www.mctplc.com
โ แดแแแซแ แ แซแแแต: https://t.me/mctplc
โ email: mct16plc@gmail.com
โ แฒแญแถแญ แ แซแแแต tiktok.com/@mctplc
โ แต.แ: 0929273364
โ แแฅแณแญแต www.mctplc.com
โ แดแแแซแ แ แซแแแต: https://t.me/mctplc
โ email: mct16plc@gmail.com
โ แฒแญแถแญ แ แซแแแต tiktok.com/@mctplc
โ
#แแฎแแซแแแ แแแแ
แแแตแ แแ?
(what is programming language)?
แแแแญแซ programming language แจแแแ แแแญ แจแแจแณแฝแ แ แแต #แแฎแแซแ แแแตแ แแ(what is program) แจแแแแ แฅแแแแจแต #แแฎแแซแ แแแต แ แ แญแฉ แ แแตแ แแแญ แแแฅแซแต แแญแ แแคแต(output)แแแแแต แ แ แตแแซ แจแแแ แแธแ แแแฎแฝ แฅแฅแฅแฅ แแฎแแซแ แญแฃแแแข
แแแฃแ แซแญแต แแแแแต *805*....# call แฅแแฐแแแแ แแแต แแ แคแจแ แซแฅแแฃแแ แแฅแญ แตแญแญแ แจแแ Dear Customer, your prepaid account has been recharged succesfully แจแแ text แญแฐแญแ แแ แแแต แแแข แแฅแฉแ แแ แ แแณแตแแกแ แต แแ แแฐแแ แฅแตแจแฑ แ แแซแ แจแฎแจแฅ แแแญแต แแญแ แฐแแ แจแแตแแแต แจแซแญแต แแฅแญ แ แแต แฒแแต แขแแตแ แฒแตแฐแ แ แญแฐแซแแข
แแญ แฅแแฐแแ แแฎแแซแแฝแแ แตแญแญแ แจแแ แแคแต(output) แฅแแแแแ แซแแแ แฐแแ แฅแ แฐแต แจแแ แแคแต แฅแแแแแ แแญแ แตแ แฐแต แแ แญแแ แแแต แแแข
แแแฃแ แฆแจแณแฝ แซแแแ C++ แแฎแแซแ แฅแแแแจแต
#include <iostream>;
using namespace std;
int main( )
{
cout<<" Hello, World "<<endl;
return 0;
}
output : Hello, World
แญแ แจแแญ แ แฅแแแแแ แจแฐแแแ แแฃแ" Hello, World " แจแแแแ แ แแ screenu แแญ แซแฃแจแแ แฅแแแ แญแ แแ แแแญ แแฎแแซแ แฅแแแแแ แแแต แแแข แจแแญ แฃแแ แแฎแแซแ แแญ แจแแแแชแซแแน แแแต แแตแแฎแฝ แแแแแ แจ C++ code แ แแตแฐแฉแ แต แแ แจแแตแ แแแธแ แฒแแ แจแแณแตแแกแตแ แฎแต แฎแแแญแแซแนแ แฅแแฒแจแณแ แจแแจแฑ แแ แจแต แจแแแฃแธแ แแแฎแฝ แแธแแข
แจแแญ แซแแแ แแฎแแซแ run แ แแณแฐแญแแ แต แแ แต แฎแแแแฐแซแนแ แแญ HI ATC แจแแ out put แญแแฃแแนแแ cout<< ____ ; แฐแฅแ แจแแแฃ แแแแแ แ แญแแต data แแฎแแซแแ แจแญแณแนแ run แตแณแฐแญแ แฎแแแแฐแซแนแ แแญ แญแแฃแ แแแต แแ int main( ) แจแแแ แจแแณแตแแกแต แแแญ แ แแ integer แแแแ แแฎแแแญแแฉ แซแณแแแแ
The syntax for preprocessor directive statement is
#include <headerfilename.h>
The .h extension tells the compiler that the file is a header file. The preprocessor directive
statement instructs the compiler to bring all the contents of the header file to our program.
Some of the header files that we are going to use are:
iostream.h: - contains standard input and output functions.Some of the functions defined ( แฅแ แแแณแแแต แจแฐแ แแแแ แจheader type แแ แแแฝแ แแ แฅแ แแแณแ math.h แจแแฃแ แจแแฐแญ แ แญแแต แ แ แฅแ แแ แจแแแฐแซแ แแฎแแซแ แแญ Mathematical formula och like cosine, sine, tangent, quadratic equation...แแแฐ แฒแแฉ แญแ แแ แฅแแ แแแแ แแแณแ แซแแฉแแฐแญ แแตแซแต แฅแตแแแ # include <math.h> แจแแ แแแขแซ แแ แแ แญแแญแฃแนแแ
Here are:
Cin>>: is a standard input function that accepts input from the user. Syntax:
For single input
Cin>>var1; // var แแแต แแแแแ แจแแณแตแแกแต แแแญ แแแต แแ
For multiple inputs
Cin>>var1>>var2>>var3; // แจแแณแตแแงแธแ inputs
Cin will take value from the keyboard and store it in the memory. Thus the cin statement needs a variable that is a reserved memory place holder.
Cout<<: standard output function that displays its content to the Screen.Syntax:
For single output
Cout<<Var1;
For multiple outputs
Cout<<var1<<โ, โ<<var2<<โ and โ<<var3;
<<endl: standard output function that displays a new line character
โบ แแฎแแซแแแ แแแแ แแแตแ แแ แฆ
แแฎแแซแแแ แแแแ แแแต แจแซแก แจแแ แจแ แแแ แ แ แซแแ แแ แจแแแฝแแธแ แฝแฎแแซแแฝ แจแแซแฅแฐแณแตแญ แแแต แแแข
โ sorce code แฅแแจแแแแ แแฎแแซแ
โ machine language แฎแแแแฐแญ แจแแจแณแ แต แแแ แแแต แแแข
๐ syntax(แฃแญแแณแญแฅ)
แจแแญ แแแฅแแฅ แฅแแฐ แแจแญแฉแต แแฎแแซแแแ แแแแ แแแต แจแซแก แจแแ แจแ แแแ แ แ แ แแ แญแ แจแ แแแ แ แ แฃแญแแณแญแฅ(syntax)แญแฃแแแข
Like แ แแญแ แแญ แ แแ แ แฅแแแแแ แแญ แฐแแ แแซแแญ แฅแแฐแแแแ แแแต แแแข #แแแฃแ แญแ แ แแฎแแซแ แฅแแแแจแต แฅแแ แแญ แจแฐแแแ แฅแซแแณแแฑ แแแญ syntax แแ แจแต แซแฐแจแ แแแข
#include <iostream>
using namespace std;
int main( )
{
cout<<" hello world"<<endl;
return 0;
}
แแแฃแ แ แแตแ แ แจแแฐ แแแญ แ แแ แฅแแจแญแฅ แแ แแญแ แ แซแต แแฅแฅ แคแแฅแแแแแ แ แแต แแฅแฅ(full stop)&แ แแฎแแซแแแ แแแแ แฐแแ" ; " แฅแแ แแแแ แแแญ แแ แแแ แแฎแแซแแแ แแแแ แแแต แฃแญแแ C++ แจแแฎ แ แฅแแแน " ; "แญแ แแแแข
แฅแ #แแฎแแซแแแ แแแแ (แแแ) แญแ แ แซแ แ แซแแซแ แ แแแ แ แแ แแ แจแแฃแแตแ แฅแแฅแแต แ แ แแ แ แ แต แ แ แแแฝแ แแญ แฅแ แ แญแแต แฅแ แฅแ แ แซแแธแ แแฎแแซแแแ แแแแ แแฝ แ แ แจแแญแกแ แแซแจแ แ แแแแต แจแแ แแกแต แจแแจแฐแแต แแธแ
โ JS(javascript)
โ C
โ phyton
โ C++
โ Go(Go lang)
โ C#
โ Java
โ CSS
โ Php
โ html etc...
โโแผแญโปโปแญแฐแจแ แฅแ แแแ แจแแแแ
#แแแตแ #แฅแ แถแฝ แ แแ!
#แจแฐแแฉแตแ_แแตแฐแแญ #แซแแแตแ_แแณแแ #แฅแแ แแต แแ
แ แฐแจแแชแ แจแฉแฒแฉแฅ แปแแแฝแแ Subscribe แ แแตแญแ แแแฝ แแจแแแฝ แญแธแแฑ
โโโโโขโขโโโโโโขโขโโโ
๐๐๐๐๐๐๐๐๐๐๐๐
https://www.youtube.com/channel/UCZBIP6PqUdmmagdTjbyp_AQ
แ แแ แจแดแแแซแ แปแแ
https://t.me/MuhammedComputerTechnology
แฅแฉ แฅแฉ แตแแฎแแแแฐแญแ แดแญแแแ แแจแแแฝ แฅแ แฅแแแถแฝ แญแแแแ แซแแแตแ แฅแแแต แซแณแตแแ
แ แดแแแซแ แปแแ แ แแแฃแต แฅแ แแจแแแฝแ แแแแต แตแฝแแแฝแแข
(what is programming language)?
แแแแญแซ programming language แจแแแ แแแญ แจแแจแณแฝแ แ แแต #แแฎแแซแ แแแตแ แแ(what is program) แจแแแแ แฅแแแแจแต #แแฎแแซแ แแแต แ แ แญแฉ แ แแตแ แแแญ แแแฅแซแต แแญแ แแคแต(output)แแแแแต แ แ แตแแซ แจแแแ แแธแ แแแฎแฝ แฅแฅแฅแฅ แแฎแแซแ แญแฃแแแข
แแแฃแ แซแญแต แแแแแต *805*....# call แฅแแฐแแแแ แแแต แแ แคแจแ แซแฅแแฃแแ แแฅแญ แตแญแญแ แจแแ Dear Customer, your prepaid account has been recharged succesfully แจแแ text แญแฐแญแ แแ แแแต แแแข แแฅแฉแ แแ แ แแณแตแแกแ แต แแ แแฐแแ แฅแตแจแฑ แ แแซแ แจแฎแจแฅ แแแญแต แแญแ แฐแแ แจแแตแแแต แจแซแญแต แแฅแญ แ แแต แฒแแต แขแแตแ แฒแตแฐแ แ แญแฐแซแแข
แแญ แฅแแฐแแ แแฎแแซแแฝแแ แตแญแญแ แจแแ แแคแต(output) แฅแแแแแ แซแแแ แฐแแ แฅแ แฐแต แจแแ แแคแต แฅแแแแแ แแญแ แตแ แฐแต แแ แญแแ แแแต แแแข
แแแฃแ แฆแจแณแฝ แซแแแ C++ แแฎแแซแ แฅแแแแจแต
#include <iostream>;
using namespace std;
int main( )
{
cout<<" Hello, World "<<endl;
return 0;
}
output : Hello, World
แญแ แจแแญ แ แฅแแแแแ แจแฐแแแ แแฃแ" Hello, World " แจแแแแ แ แแ screenu แแญ แซแฃแจแแ แฅแแแ แญแ แแ แแแญ แแฎแแซแ แฅแแแแแ แแแต แแแข แจแแญ แฃแแ แแฎแแซแ แแญ แจแแแแชแซแแน แแแต แแตแแฎแฝ แแแแแ แจ C++ code แ แแตแฐแฉแ แต แแ แจแแตแ แแแธแ แฒแแ แจแแณแตแแกแตแ แฎแต แฎแแแญแแซแนแ แฅแแฒแจแณแ แจแแจแฑ แแ แจแต แจแแแฃแธแ แแแฎแฝ แแธแแข
แจแแญ แซแแแ แแฎแแซแ run แ แแณแฐแญแแ แต แแ แต แฎแแแแฐแซแนแ แแญ HI ATC แจแแ out put แญแแฃแแนแแ cout<< ____ ; แฐแฅแ แจแแแฃ แแแแแ แ แญแแต data แแฎแแซแแ แจแญแณแนแ run แตแณแฐแญแ แฎแแแแฐแซแนแ แแญ แญแแฃแ แแแต แแ int main( ) แจแแแ แจแแณแตแแกแต แแแญ แ แแ integer แแแแ แแฎแแแญแแฉ แซแณแแแแ
The syntax for preprocessor directive statement is
#include <headerfilename.h>
The .h extension tells the compiler that the file is a header file. The preprocessor directive
statement instructs the compiler to bring all the contents of the header file to our program.
Some of the header files that we are going to use are:
iostream.h: - contains standard input and output functions.Some of the functions defined ( แฅแ แแแณแแแต แจแฐแ แแแแ แจheader type แแ แแแฝแ แแ แฅแ แแแณแ math.h แจแแฃแ แจแแฐแญ แ แญแแต แ แ แฅแ แแ แจแแแฐแซแ แแฎแแซแ แแญ Mathematical formula och like cosine, sine, tangent, quadratic equation...แแแฐ แฒแแฉ แญแ แแ แฅแแ แแแแ แแแณแ แซแแฉแแฐแญ แแตแซแต แฅแตแแแ # include <math.h> แจแแ แแแขแซ แแ แแ แญแแญแฃแนแแ
Here are:
Cin>>: is a standard input function that accepts input from the user. Syntax:
For single input
Cin>>var1; // var แแแต แแแแแ แจแแณแตแแกแต แแแญ แแแต แแ
For multiple inputs
Cin>>var1>>var2>>var3; // แจแแณแตแแงแธแ inputs
Cin will take value from the keyboard and store it in the memory. Thus the cin statement needs a variable that is a reserved memory place holder.
Cout<<: standard output function that displays its content to the Screen.Syntax:
For single output
Cout<<Var1;
For multiple outputs
Cout<<var1<<โ, โ<<var2<<โ and โ<<var3;
<<endl: standard output function that displays a new line character
โบ แแฎแแซแแแ แแแแ แแแตแ แแ แฆ
แแฎแแซแแแ แแแแ แแแต แจแซแก แจแแ แจแ แแแ แ แ แซแแ แแ แจแแแฝแแธแ แฝแฎแแซแแฝ แจแแซแฅแฐแณแตแญ แแแต แแแข
โ sorce code แฅแแจแแแแ แแฎแแซแ
โ machine language แฎแแแแฐแญ แจแแจแณแ แต แแแ แแแต แแแข
๐ syntax(แฃแญแแณแญแฅ)
แจแแญ แแแฅแแฅ แฅแแฐ แแจแญแฉแต แแฎแแซแแแ แแแแ แแแต แจแซแก แจแแ แจแ แแแ แ แ แ แแ แญแ แจแ แแแ แ แ แฃแญแแณแญแฅ(syntax)แญแฃแแแข
Like แ แแญแ แแญ แ แแ แ แฅแแแแแ แแญ แฐแแ แแซแแญ แฅแแฐแแแแ แแแต แแแข #แแแฃแ แญแ แ แแฎแแซแ แฅแแแแจแต แฅแแ แแญ แจแฐแแแ แฅแซแแณแแฑ แแแญ syntax แแ แจแต แซแฐแจแ แแแข
#include <iostream>
using namespace std;
int main( )
{
cout<<" hello world"<<endl;
return 0;
}
แแแฃแ แ แแตแ แ แจแแฐ แแแญ แ แแ แฅแแจแญแฅ แแ แแญแ แ แซแต แแฅแฅ แคแแฅแแแแแ แ แแต แแฅแฅ(full stop)&แ แแฎแแซแแแ แแแแ แฐแแ" ; " แฅแแ แแแแ แแแญ แแ แแแ แแฎแแซแแแ แแแแ แแแต แฃแญแแ C++ แจแแฎ แ แฅแแแน " ; "แญแ แแแแข
แฅแ #แแฎแแซแแแ แแแแ (แแแ) แญแ แ แซแ แ แซแแซแ แ แแแ แ แแ แแ แจแแฃแแตแ แฅแแฅแแต แ แ แแ แ แ แต แ แ แแแฝแ แแญ แฅแ แ แญแแต แฅแ แฅแ แ แซแแธแ แแฎแแซแแแ แแแแ แแฝ แ แ แจแแญแกแ แแซแจแ แ แแแแต แจแแ แแกแต แจแแจแฐแแต แแธแ
โ JS(javascript)
โ C
โ phyton
โ C++
โ Go(Go lang)
โ C#
โ Java
โ CSS
โ Php
โ html etc...
โโแผแญโปโปแญแฐแจแ แฅแ แแแ แจแแแแ
#แแแตแ #แฅแ แถแฝ แ แแ!
#แจแฐแแฉแตแ_แแตแฐแแญ #แซแแแตแ_แแณแแ #แฅแแ แแต แแ
แ แฐแจแแชแ แจแฉแฒแฉแฅ แปแแแฝแแ Subscribe แ แแตแญแ แแแฝ แแจแแแฝ แญแธแแฑ
โโโโโขโขโโโโโโขโขโโโ
๐๐๐๐๐๐๐๐๐๐๐๐
https://www.youtube.com/channel/UCZBIP6PqUdmmagdTjbyp_AQ
แ แแ แจแดแแแซแ แปแแ
https://t.me/MuhammedComputerTechnology
แฅแฉ แฅแฉ แตแแฎแแแแฐแญแ แดแญแแแ แแจแแแฝ แฅแ แฅแแแถแฝ แญแแแแ แซแแแตแ แฅแแแต แซแณแตแแ
แ แดแแแซแ แปแแ แ แแแฃแต แฅแ แแจแแแฝแ แแแแต แตแฝแแแฝแแข
๐8โค1