โป ๋ณธ ํฌ์คํ ์ ์ ํ๋ธ C++ Full Course ๊ฐ์๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ์ ๊ฐ ์ง์ ์ ๋ฆฌํ C++ ๊ธฐ๋ณธ ๋ฌธ๋ฒ์ ๋ํ ๊ธ์ ๋๋ค.
์๋ก ์ ์ ๊น ๋งํ์๋ฉด, C++์ ๋ํด ๋ฐฐ์ด ๊ฒ์ ๊น๋จน์ง ์๊ธฐ ์ํด ๋ธ๋ก๊ทธ์ ์ ๋ฆฌํ๋ ๊ฒ์ ๋๋ค. ๊ธฐ๋ณธ์ ์ผ๋ก ๋ค๋ฅธ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด๋ฅผ ๋ค๋ฃฌ ์ ์ด ์๊ธฐ ๋๋ฌธ์ ๊ฐ์ ์์์ ๋ณด๊ณ ์ ๊ฐ ์ ๋ง์๋๋ก ๋นผ๊ฑฐ๋ ์ถ๊ฐํ๋ฉด์ ์ ๋ฆฌํ ์์ ์ ๋๋ค. ์ต๋ํ ํ๋ฆฐ ๋ถ๋ถ์ด ์์ง ์๊ฒ ์ ๊ฒ ์ง๋ง ํน์ ์๋ชป๋ ๋ถ๋ถ์ด ์์ผ๋ฉด ์๋ ค์ฃผ์ธ์!
๊ฐ์๋ Bro Code๋ผ๋ ์ ํ๋ฒ์ ์ด 6์๊ฐ ๋ถ๋์ ๊ฐ์์ ๋๋ค. ์์์์ ๋๋ ์ ธ ์๋ ์ฑํฐ ์ ๋ชฉ์ ๊ธฐ์ค์ผ๋ก ์์ฑํ ์์ ์ ๋๋ค. ๋ค๋ง ์์ด๊ฐ์๋ผ๋ ์ ์ด ์ข ๊ฑธ๋ฆฌ๋๋ฐ..ํ๊ตญ์ด ๊ฐ์๋ฅผ ์ฐพ๋ค๊ฐ ์ปดํฉํธ ํ๋ฉด์ ์ ๊ฐ ์ง๋ฃจํ์ง ์๊ณ ์ ๋ฐฐ์ธ ์ ์๋ ์์์ ๋ชป์ฐพ์์ ์์ด๊ฐ์๋ฅผ ๋ฃ๊ฒ ๋์์ต๋๋ค. ํน์ ์ด ๋ธ๋ก๊ทธ๋ฅผ ๋ณด์๊ณ ๋ค์ ์๊ฐ์ ๊ฐ์ง ๋ถ์ด ๊ณ์๋ค๋ฉด ์์ด์๋ง๋ ์๊ณ ์ด์ํ์ง๋ง ์๋๋ฒ์ญ๋๋ ํ๊ธ์๋ง๋ ์์ผ๋ ๋๋ฌด ๊ฒ๋จน์ง ๋ง์๊ณ ๋ค์ด๋ณด๊ธธ ๋ฐ๋๋๋ค:)
< 1. Hello, World! >
#include <iostream>
int main(){
std::cout << "It's really good!" << '\n';
//๋์ผ๋ฌธ์ฅ
//std::cout << It's really good!" << std::endl;
return 0;
}
// This is a comment
/*
This
is
a
multi-line
comment
*/
๋ชจ๋ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด์ ์์์ธ Hello,World!
๋ฌผ๋ก ์ฝ๋ ๋ด์๋ ์ ์ง ์์์ง๋ง ๊ธฐ๋ณธ์ ์ผ๋ก ์ฒ์ ์ถ๋ ฅํจ์๋ฅผ ํตํด output์ ๋ผ ๋ ๋น ์ง์ง ์๊ณ ๋ฑ์ฅํ๋ ๋ฌธ์ฅ์ด๋ค.
C++์ ๊ฐ์ฅ ๊ธฐ๋ณธ์ด ๋๋ ๊ตฌ์กฐ๋ฅผ ์ ์ด๋ณด์๋ค.
โ #include <iostream> ํค๋ ๋ฌธ์ฅ์ด๋ค.
์ฌ๊ธฐ์ iostream์ input output stream์ ์ฝ์์ด๊ณ ๋ง ๊ทธ๋๋ก input and output function๋ค์ ์ฌ์ฉํ ์ ์๊ฒ ํด์ค๋ค.
โก std::cout << "It's really good!";
std๋ standard์ ์ฝ์์ด๊ณ cout์ ์ถ๋ ฅํจ์์ด๋ค ๋ฐ๋๋ก ์ ๋ ฅํจ์๋ cin์ด๋ค.
โข int main(){} / return 0;
๊ฐ์ฅ ๊ธฐ๋ณธ์ ์ผ๋ก ์ถ๋ ฅ์ ํ๊ธฐ ์ํด ์ด mainํจ์์ 2๋ฒ ๋ฌธ์ฅ์ ์ ์ผ๋ฉด ๋๋ค.
return 0; ์ ๋์ค์ ์๋ ๊ฒฝ์ฐ๋ ์์ผ๋ ค๋? ์์ง ๋ชจ๋ฅด๊ฒ ๋ค.
(์ถ๊ฐ)
- ๋ ๋ฌธ์ฅ์ด ๋ฐ๋ณต๋ ๋ ๋ฌธ์ฅ์ด ๋ ํ์ผ๋ก ๋์ค๊ฒ ์ค์ ๋์ฐ๋ ค๋ฉด ์ฝ๋์ฒ๋ผ '\n' ๋๋ std::endl์ ๋ค์ ๋ถ์ด๋ฉด ๋๋ค.
- ์ฃผ์์ ๊ฒฝ์ฐ ํ์ค ์ฃผ์์ // ๋์ค์ด์์ ์ฃผ์์ฒ๋ฆฌํ ๋๋ /* */ ์์ ์ ์ผ๋ฉด ๋๋ค.
< 2. Variables and basic data types >
#include <iostream>
int main() {
int x; //declaration(์ ์ธ)
x = 5; //assignment(ํ ๋น)
// int x = 5; ๋์ผ
std::cout << x << '\n';
return 0;
}
int main() {
//integer (whole number)
int age = 21;
//double (number including decimal)
double price = 10.99;
//single character
char grade = 'A'; // single ์ ๋์ด๊ฐ๋ฉด warning์ ๋ฐ๊ฒ ๋จ
char dollarSign = '$'; //ํน์๋ฌธ์๋ single character๋ก ์ทจ๊ธ
//boolean (true or false)
bool power = false;
//string (objects that represents a sequence of text)
std::string day = "Sunday";
std::string address = "123 Fake St."; // string ์ number ๋ฃ์ ์ ์์ง๋ง integer์ ๋ค๋ฅด๊ฒ ์ทจ๊ธ
std::cout << "You are " << age << " years old" << '\n';
return 0;
}
(์ ์ฝ๋์๋ main ํจ์๊ฐ ๋ ๊ฐ ์ ํ์์ง๋ง, ์คํํ ๋๋ ํ๋๋ ์ฃผ์ ์ฒ๋ฆฌ๊ฐ ํ์ํจ)
๋ณ์์ ๊ธฐ๋ณธ์ ์ธ ๋ฐ์ดํฐ ํ์ ์ ๋ํ ์ฑํฐ์ด๋ค.
์ ์ธ๊ณผ ํ ๋น์ ๋ฐ๋ก ํ ์๋ ์๊ณ ๋์์ ํ ์๋ ์๋ค.
๊ธฐ๋ณธ์ ์ผ๋ก ์ ์, ์ค์, character, string, boolean ์ ๋๊ฐ C++์์ ์ด๋ป๊ฒ ๋ค๋ฃจ์ด์ผ ํ๋์ง ๋ณผ ์ ์๋ค.
*์ฌ๊ธฐ์ ๋์ ๊ถ๊ธ์ฆ์ single character์ผ ๋๋ single quote(')๋ฅผ ์ฌ์ฉํ๊ณ string์ผ ๋๋ double quote(")๋ฅผ ์ฌ์ฉํ๋๋ฐ ์ด ๋ถ๋ถ์ด ๊ด๋ก์ ์ธ ๋ถ๋ถ์ธ์ง ๋ฌธ๋ฒ์ ๋ฌด์กฐ๊ฑด ์ง์ผ์ผ ํ๋ ๋ถ๋ถ์ธ์ง์๋ค.
//char ๋ณ์์ double quote ์ผ์ ๋์ ์ค๋ฅ
error: cannot initialize a variable of type 'char' with an lvalue of type 'const char[2]'
//string ๋ณ์์ single quote ์ผ์ ๋์ ์ค๋ฅ
warning: character constant too long for its type
error: no viable conversion from 'int' to 'std::string'
→ ์ง์ ํด ๋ณธ ๊ฒฐ๊ณผ ๋ฌธ๋ฒ์ ์ผ๋ก ๋ฌด์กฐ๊ฑด ์ง์ผ์ผ ํ๋ ๋ถ๋ถ์ด๋ผ๋ ๊ฒฐ๊ณผ๊ฐ ๋์๋ค.
< 3. Const >
#include <iostream>
int main() {
const double PI = 3.14159;
double radius = 10;
double circumference = 2 * PI * radius;
// const -> read only and can't be changed
std::cout << circumference << "cm";
return 0;
}
const ํค์๋๋ ์ง์ ํ๋ฉด ๋ณ์๊ฐ์ ๋ณ๊ฒฝํ ์ ์๋ค.
๊ธฐ๋ณธ์ ์ผ๋ก ์์(const) ํค์๋๋ฅผ ์ ์ ๋ ๋ณ์๋ช ์ ๋๋ฌธ์๋ก ์ ๋ ๊ฒ ๋ซ๋ค.
๋ณ๊ฒฝ์ ์๋ํ๋ฉด
note: variable 'PI' declared const here
๋ผ๊ณ ์ค๋ฅ๊ฐ ๋ฌ๋ค.
const์ ์ญํ ์ read only๋ผ๊ณ ์๊ฐํ ์ ์๋ค.
< 4. Namespaces >
#include <iostream>
namespace first {
int x = 1;
}
namespace second {
int x = 2;
}
int main() {
int x = 0;
// int x = 1; //error: redefinition of 'x' ๋ผ๋ ์ค๋ฅ๊ฐ ๋์ด
// std::cout << x;
//์ฌ์ฉํ๊ณ ์ ํ๋ namespace๋ฅผ ์ง์ ํ์ง ์์๊ธฐ ๋๋ฌธ์ local x ๊ฐ output
std::cout << second::x;
return 0;
}
Namespace๋ ํฐ ํ๋ก์ ํธ์์ ์ด๋ฆ์ด ๊ฐ์์ ์๊ธฐ๋ ์ถฉ๋์ ๋ฏธ๋ฆฌ ๋ฐฉ์งํ๊ธฐ ์ํด ๋ง๋ค์ด์ก๋ค.
๊ฐ๊ฐ์ ๊ฐ์ฒด๋ค์ ๊ฐ๊ฐ์ uniqueํ ์ด๋ฆ์ ๊ฐ์ ธ์ผ ํ๋ค. ๋์ผํ ์ด๋ฆ์ namespaces๊ฐ ๋ค๋ฅด๋ค๋ ์ ์ ํ์ ๊ฐ์ง ์ ์๋ค.
์ฌ๊ธฐ์ ๋จผ์ main ํจ์๋ฅผ ๋ณด๋ฉด,
int x = 0; ์ด๋ผ๊ณ ์ ์ธ๊ณผ ํ ๋น์ ํ๊ธฐ์ x์ ๊ฐ๋ง ๋ฐ๊พธ๋ ค๊ณ ํ๋ฉด ๊ทธ๊ฑด ์์๊ฐ ์๋๊ธฐ์ ๊ฐ๋ฅํ์ง๋ง, ๋๊ฐ์ x๋ฅผ ๋ค์ ์ ์ธํ ์๋ ์๋ค.
์ด๋ ๊ฐ์ namespace(mainํจ์) ์์ ์๊ธฐ ๋๋ฌธ์ด๋ค.
๋ฐ๋ฉด namespace๊ฐ ๋ค๋ฅธ ๊ฒฝ์ฐ์๋ ๊ฐ์ ๋ณ์๋ช ์ ์ฌ์ฉํ ์ ์๋ค.
์์ namespace first์ namespace second๋ฅผ ๋ณด๋ฉด ์ ์ ์๋ฏ์ด ๊ฐ์ ๋ณ์๋ช x๋ฅผ ์ผ์ง๋ง ์ปดํ์ผ๊น์ง ์ค๋ฅ๊ฐ ๋์ง ์๋๋ค.
๋ํ mainํจ์ ์์์ x๋ฅผ ์ถ๋ ฅํ๊ณ ์ ํ ๋ ๋ฐ๋ก ์ง์ ํด์ฃผ์ง ์์ผ๋ฉด local x๊ฐ output์ด ๋๋ค.
-> output = 0
๋ฐ๋ก ์ง์ ํ๋ ๊ฒฝ์ฐ ์ ์ฝ๋์ ๊ฐ์ด std::cout << second::x; ์ฒ๋ผ x ์์ namespace๋ฅผ ์ง์ ํด ์ค์ผ ํ๋ค.
-> output = 1
* ์ฌ๊ธฐ์ ::๋ ๋ฒ์ ํ์ธ ์ฐ์ฐ์์ด๋ค.
int main() {
using namespace std;
string name = "chaeon";
cout << "Hello " << name;
return 0;
}
main ํจ์ ์์์ namespace๋ฅผ outputํ๋ ค๋ ๋ณ์๋ช ์์ ์ผ์ผ์ด ์ง์ ํ์ง ์๊ณ ๊ณ ์ ์ํค๋ ๋ฐฉ๋ฒ์ด ์๋๋ฐ, ๊ทธ๊ฒ using namespace ๋ฌธ์ฅ์ด๋ค.
์ ์ฝ๋์๋ ์์ง๋ง ์ ์์์์ using namespace first;๋ผ๋ ๋ฌธ์ฅ์ main์ ๋ฃ์ผ๋ฉด first namespace๋ผ๋ ๊ฑธ ์ถ๋ ฅํ ๋ ์ง์ ํ์ง ์์๋ x์ output์ 1์ด ๋๋ค.
๋จ, ์ด ๊ฒฝ์ฐ์๋ ๋ง์ฝ namespace second์ x๊ฐ์ ์ฐ๊ณ ์ถ์ ๋๋ ๋ฒ์ํ์ธ์ฐ์ฐ์๋ก ๋ถ์ฌ์ค์ผ ํ๋ค.
์ด์ฒ๋ผ ์์ฃผ ์ฐ์ด๋ ๋ฌธ์ฅ์ด using namespace std ์ธ๋ฐ ์ด๊ฑธ ์ฐ๋ฉด ์ ์ฝ๋์ฒ๋ผ ์ถ๋ ฅํ ๋ cout์์ std๋ฅผ ๋ถ์ผ ํ์๊ฐ ์๋ค. ๋ค๋ง std namespace์์๋ ๋๋ฌด ๋ง์ name๋ค์ด ์๊ธฐ ๋๋ฌธ์ ํ์์ ์ผ๋ก ํ์ํ ์ํฉ์ ์ ์ ํ ํ์ฉํ๋ ๊ฒ์ด ์ข๋ค.
< 5. Typedef and type aliases >
#include <iostream>
typedef std::string text_t;
typedef int number_t;
// ์ ๋์ค๊ณผ ์๋ ๋์ค์ ๋์ผํ ๋์ ์ํ
using text_t = std::string;
using number_t = int;
int main() {
text_t firstName = "chaeon";
number_t age = 15;
std::cout << firstName << '\n';
std::cout << age << '\n';
return 0;
}
typedef ๋ ๋ฐ์ดํฐ ํ์ ์ด ๋ณต์กํ ๋ ๋ณ์นญํค์๋๋ฅผ ์ ๊ณตํด์ฃผ๋ ๋๊ตฌ๋ผ๊ณ ํ ์ ์๋ค.
typedef ๋์ using์ ์ด์ฉํด์๋ ๋๊ฐ์ ๋์์ ์ํํ ์ ์๋ค.
ํ์ฌ๋ ๋ฐ์ดํฐ ํ์ ์ด ๋ณต์กํ์ง ์์ง๋ง ์ดํ ๋ณต์กํ ๋ฐ์ดํฐ ํ์ ์ด ๋ณด์ด๋ฉด ์ ์ฉํ๊ฒ ์ธ ๊ฒ ๊ฐ๋ค
๊ทธ๋ฆฌ๊ณ typedef ๋ณ์นญ์ ์ง์ ๋๋ _t๋ฅผ ๋ถ์ด๋ ๊ฒ ์ผ๋ฐ์ ์ด๋ค.
์ฒซ ๊ธ์ด๋ผ์ ๋๋ฌด ์์ธํ๊ฒ ์ด ๊ฒ ๊ฐ๋ค. ์๋ง ๋ค์๊ธ์์๋ ํจ์ฌ ๋ ๊ฐ๊ฒฐํ๊ฒ ๋ด์ฉ์ ํฌ์คํ ํ ๊ฒ ๊ฐ๋ค.
ํน์ ํ๋ฆฐ ๋ถ๋ถ์ด๋ ์ถ๊ฐํด์ฃผ๊ณ ์ถ์ ๋ถ๋ถ์ด ์์ผ๋ฉด ์๋ ค์ฃผ์ธ์.