02. 연산자 / 함수 / 클래스

 

 

< 연산자 >

#include <iostream>
using namespace std;

// 메모리 영역
// STACK - HEAP - DATA - CODE

// 01. 연산자 

// 데이터 연산 및 가공 가능

// 1) 산술 연산자
// 2) 대입 연산자
// 3) 증감 연산자
// 4) 비교 연산자
// 5) 논리 연산자
// 6) 비트 연산자
// 7) 삼항 연산자

int a = 1;
int b = 7;

bool isSame;
bool isDiff;
bool isGreater;
bool isSmaller;
bool test;

int hp = 100;
bool isInvincible = true;

unsigned char flag;

const int Air = 0;
const int Stun = 1;
const int PolyMorph = 2;
const int Invincible = 3;

int main()
{
	// 01) 산술 연산자
	// 사칙 연산
	// 데미지 계산, 체력 깎기, 루프문 등 다양한 곳에서 사용

	a = a + 3;  // add  (연산자가 같은 의미)a += 3
	cout << a << endl;
	a = b - 3; // sub						a -= 3
	cout << a << endl;
	a = b * 3; // mul						a *= 3
	cout << a << endl;
	a = b / 3; // 나눗셈 div				a /= 3
	cout << a << endl;
	a = b % 3; // 나머지 dic				a %= 3
	cout << a << endl;


	// 02) 대입 연산자
	// = : 수학에서는 같다의 의미지만, 코딩에선 대입
	a = b;  // a를 b에 대입하고 b 반환
	cout << a << " " << b << endl;

	// +=  -=  *=  /=  %=


	// 03) 증감 연산자
	// 1씩 증가 혹은 감소시킬 때 사용

	// 7  7
	b = a++;
	cout << a << " " << b << endl;   // 8  7
	b = ++a; 
	cout << a << " " << b << endl;   // 9  9
	b = a--;
	cout << a << " " << b << endl;   // 8  9
	b = --a;
	cout << a << " " << b << endl;   // 7  7


	// 04) 비교 연산자
	// 두 항 사이의 크기를 비교하는 연산자
	// ex) 체력이 0되면 사망, 체력이 30%이하면 무적 발동 등
	// 즉 특정 조건이 되면 어떠한 event

	// a == b : a와 b가 같은가?
	// 같으면 1, 다르면 0
	isSame = (a == b);
	cout << isSame << endl;

	// a != b : a와 b가 다른가?
	// 다르면 1, 같으면 0
	isDiff = (a != b);
	cout << isDiff << endl;

	// a > b . a >= b
	isGreater = (a > b);
	cout << isGreater << endl;

	// a < b . a <= b
	isSmaller = (a < b);
	cout << isSmaller << endl;


	// 05) 논리 연산자
	// 언제 필요한가? 조건에 대한 논리적 사고가 필요
	// ex) 로그인할 때 아이디도 같고 + 비번도 같아야 한다 (동시에 만족해야 함)
	// ex) 길드 마스터이거나 운영자 계정이면 길드 해산가능 (OR)

	// ! not
	test = !isSame; // isSame 값을 반대로, isDiff와 같은 의미
	cout << test << endl;

	// && and
	// a && b -> 둘다 1이면 1, 그외 0 (두 조건 만족해야함)
	test = (hp <= 0 && isInvincible == false);; //죽음
	cout << test << endl;

	// || or
	// a || b -> 둘 중 하나라도 1이면 1 (둘다 0이면 0)
	test = (hp > 0 || isInvincible == true); //생존
	cout << test << endl;


	// 06) 비트 연산자
	// 언제 필요한가?
	// ex) 비트 단위의 조작이 필요할 때 
	// 대표적으로 BitFlag

	// ~ bitwise not
	// 단일 숫자의 모든 비트를 대상으로 0을 1로, 1을 0으로 바꿈

	// & bitwise and
	// 두 숫자의 모든 비트 쌍을 대상으로 and를 한다

	// | bitwise or
	// 두 숫자의 모든 비트 쌍을 대상으로 or를 한다

	// ^ bitwise wor
	// 두 숫자의 모든 비트 쌍을 대상으로 xor한다

	// << 비트 좌측 이동
	// 비트열을 n만큼 왼쪽으로 이동
	// 왼쪽의 넘치는 n개의 비트는 버림, 새로 생성되는 n개의 비트는 0

	// >> 비트 우측 이동
	// 비트를 n만큼 오른쪽으로 이동
	// 오른쪽의 넘치는 n개의 비트는 버림
	// 왼쪽 생성되는 n개의 비트는
	// - 부호가 존재할 경우 부호 비트를 따라감
	// - 아니면 0

	// Ob0000 [무적][변이][스턴][공중부양]   4bit

	// 무적상태로 만든다
	flag = (1 << Invincible);   // 0b1000   3칸이동!

	// 변이 상태
	flag |= (1 << PolyMorph);   // Ob1100

	// 무적인지 확인하고 싶다?
	// bitmask
	bool invincible = ((flag & (1 << Invincible)) != 0);

	// 무적이거나 스턴 상태인지 확인하고 싶다
	bool stunOrInvincible = ((flag & 0b1010) != 0);

	
	// 07. 삼항 연산자
	// 조건식? 변수 1 : 변수 2
	// 결과가 true라면 변수 1을 반환, false 라면 변수 2를 반환

	int x = 20;
	int y = 14;

	int result;

	result = (x > y) ? x : y;

	cout << result << endl;

}

 

 

< 함수 >

#include <iostream>
using namespace std;


// 02. 함수
// 저번 시간에 객체에 대해 설명했는데 속성과 기능이 있다고 하였다.
// 오늘은 어떠한 객체에 대한 기능을 만드려고 한다.

// 예슬이라는 플레이어 객체가 이동하는 기능을 만들기 위해서는
// 예슬이가 이동할 수 있다는 것을 "선언"해야 하고
// 구체적으로 어떻게 이동하는지 "정의"해야 하며,
// 어떤 상황에서 뛰는지 알려주려면 뛰는 기능을 "호출" 해야 한다

class YeSeul {
public:
	void Move();       // 선언
};

void YeSeul::Move()    // 정의
{
	cout << "예슬이는 달린다" << endl;
}

int main()
{
	YeSeul player;
	player.Move();   // 호출
}

// * 함수의 구성요소
//   : 반환값 함수명 {매개변수 목록}
//   : 반환값 - 함수를 수행한 다음 반환하는 값, 없으면 void
//   : 함수명 - 함수 식별요소
//   : 매개변수 목록 : 함수의 기능을 수행하기 위한 입력값

#include <iostream>
using namespace std;

// 아래의 코드는 컴파일 에러 발생
// 클래스 변수와 클래스 멤버 함수는 사용 전에 선언되어야 한다 !!

// * 함수 선언
// 컴파일러는 함수 선언을 보고 반환값의 자료형이 무엇인지 안다
// 컴파일러는 함수 선언을 보고 매개 변수의 개수가 올바른지 확인한다
// 컴파일러는 함수 선언을 보고 매개변수의 자료형이 올바른지 확인한다

// * 함수 정의
// 정의가 없을 경우 -> LNK2019, LNK1120 오류
// 기능을 실제로 구현하는 부분이기에 없으면 안됨


int main()
{
	YeSeul player;
	player.Move();   // 호출
}

class YeSeul {
public:
	void Move();       // 선언
};

void YeSeul::Move()    // 정의
{
	cout << "예슬이는 달린다" << endl;

#include <iostream>
using namespace std;

// * 값에 의한 호출과 참조에 의한 호출 & 매개변수

// 값에 의한 호출은 변수를 복사하는 것과 같은 개념

class Restaurant
{
public:
	int steakCost;
};

class YeSeul {
public:
	void Move();       // 선언
	int Eat(int);
	int Eat2(int&);
	int Eat3(int steakCost3);
	int Eat4(int steakCost3, int coffeeCost, int iceCost);
};

void YeSeul::Move()    // 정의
{
	cout << "예슬이는 달린다" << endl;
}

int YeSeul::Eat(int steakCost2)
{
	steakCost2 = 10000;
	return steakCost2;
}

int YeSeul::Eat2(int& steakCost2)
{
	steakCost2 = 10000;
	return steakCost2;
}

int YeSeul::Eat3(int steakCost3)
{
	cout << "예슬이는 " << steakCost3 << "원짜리 스테이크를 먹는다" << endl;
	
	return steakCost3;
}

int YeSeul::Eat4(int steakCost3, int coffeeCost, int iceCost)
{
	cout << "예슬이는 " << steakCost3 << "원짜리 스테이크를 먹고, " <<
		coffeeCost << "원짜리 커피를 마시고, " <<
		iceCost << "원짜리 아이스크림을 먹는다." << endl;

	return steakCost3;
}

int main()
{
	YeSeul player;
	Restaurant rest, rest2;

	rest.steakCost = 20000;  
	rest2.steakCost = 20000;

	// rest
	cout << "예슬이는 " << player.Eat(rest.steakCost) <<
		"원짜리 스테이크를 먹었다고 거짓말 했다." << endl;   
	cout << "레스토랑은 예슬이가 " << rest.steakCost <<
		"원짜리 스테이크를 먹었다고 알고 있다." << endl;

	// rest2
	cout << "예슬이는 " << player.Eat2(rest.steakCost) <<
		"원짜리 스테이크를 먹었다고 거짓말 했다." << endl;
	cout << "레스토랑은 예슬이가 " << rest.steakCost <<
		"원짜리 스테이크를 먹었다고 알고 있다." << endl;

	// 매개변수
	player.Eat3(30000);
	player.Eat4(43333, 3000, 1000);

}

// main -> int YeSeul::Eat(int steakCost)함수 실행 -> main

// rest 실행 - 값에 의한 호출
// 함수 호출 -> 스테이크 가격이 매개변수로 들어감. 값에 의한 호출 방식


// rest2 실행 - 참조에 의한 호출
// 함수 호출 ->  매개변수를 스테이크 가격으로 초기화,
// 참조자임으로 단순히 값을 복사하는 것이 아닌 주소를 참조하여
// Eat2 함수의 streakCost는 rest2의 steakCost 변수의 별칭이 된다.
// 따라 두 변수 중 하나라도 값을 변경하게 되면 스테이크 값이 변경 됨
// 참조에 의한 호출 방식은 함수 내부에서 외부의 값을 변경할 수 있다 (매우 중요) 

// 매개변수를 여러 개 만들 수 있다.

#include <iostream>
using namespace std;

// ** 함수 오버로딩
// overloading : 짐을 많이 싣는다
// C++의 중요한 개념, 다형성과 밀접하기에
// 중요한 개념이다

// 하나의 함수에 계속 쌓는다
// 우리가 지금까지 했던 것의 이름을 동일하게 만들자
// 단 매개변수 목록은 달라야 한다. (참조인 경우 -> 타입이 같으면 x)

class Restaurant
{
public:
	int steakCost;
};

class YeSeul {
public:
	void Move();       // 선언
	int Eat(int);
	double  Eat(double);
	int Eat(int steakCost3, int coffeeCost, int iceCost);
};

void YeSeul::Move()    // 정의
{
	cout << "예슬이는 달린다" << endl;
}

int YeSeul::Eat(int steakCost3)
{
	cout << "예슬이는 " << steakCost3 << "원짜리 스테이크를 먹는다" << endl;
	
	return steakCost3;
}


double YeSeul::Eat(double steakCost3)
{
	cout << "예슬이는 " << steakCost3 << "원짜리 스테이크를 먹는다" << endl;

	return steakCost3;
}

int YeSeul::Eat(int steakCost3, int coffeeCost, int iceCost)
{
	cout << "예슬이는 " << steakCost3 << "원짜리 스테이크를 먹고, " <<
		coffeeCost << "원짜리 커피를 마시고, " <<
		iceCost << "원짜리 아이스크림을 먹는다." << endl;

	return steakCost3;
}

int main()
{
	YeSeul player;
	Restaurant rest, rest2;

	rest.steakCost = 20000;  
	rest2.steakCost = 20000;

	// rest
	cout << "예슬이는 " << player.Eat(rest.steakCost) <<
		"원짜리 스테이크를 먹었다고 거짓말 했다." << endl;   
	cout << "레스토랑은 예슬이가 " << rest.steakCost <<
		"원짜리 스테이크를 먹었다고 알고 있다." << endl;

	// 매개변수
	player.Eat(30000);
	player.Eat(30000.0);
	player.Eat(43333, 3000, 1000);

}

 

 

 

< 인라인(inline) 함수 >

#include <iostream>
using namespace std;

// * inline 함수

// 장점 : 함수 정의부가 실행 코드를 대체 하므로, 실행 상 오버헤드가 줄어 속도 빠름
// 단점 : 함수 정의부가 길면 인라인 함수를 사용하여 얻을 수 있는 장점 줄어듦
// (호출하는 구문이 모두 인라인 함수의 정의로 바뀌어 전체 코드 양이 증가함)

class YeSeul {
public:
	void Eat(int);
	inline void EatInline(int steakCost3)
	{
		cout << "EatInline() :: 예슬이는 " << steakCost3 << "원짜리 스테이크를 먹는다" << endl;
	}
};

void YeSeul::Eat(int steakCost3)
{
	cout << "Eat() :: 예슬이는 " << steakCost3 << "원짜리 스테이크를 먹는다" << endl;
}

int main()
{
	YeSeul player;
	player.Eat(500);    // 작동방식 복잡 ) main -> eat함수 -> 함수 실행 -> main
	player.EatInline(1500);    // (함수 호출 단계 줄음) 코드 대체됨 ) cout << "EatInline() :: 예슬이는 " << ....
}

 

 

 

< 람다 함수 >

#include <iostream>
using namespace std;

// * 람다 함수
// 복잡한 함수 호출 과정 생략해 시간 절약 및 가독성 UP
// : 인라인으로 정의와 호출을 한 번에 하는 함수

// [캡처]    (매개변수 목록)     mutable     예외목록    -> 반환형    {함수 몸체}


class YeSeul {
public:
	void Eat(int);
	inline void EatInline(int steakCost3)
	{
		cout << "EatInline() :: 예슬이는 " << steakCost3 << "원짜리 스테이크를 먹는다" << endl;
	}
};

void YeSeul::Eat(int steakCost3)
{
	cout << "Eat() :: 예슬이는 " << steakCost3 << "원짜리 스테이크를 먹는다" << endl;
}

int main()
{
	YeSeul player;
	player.Eat(500);    
	player.EatInline(1500);    

	[](int steakCost3) {
		cout << "eatLamda():: 예슬이는 " << steakCost3 << "원짜리 스테이크를 먹는다" << endl;}(1000);
}

 

 

 

< Class >

#include <iostream>
using namespace std;

#define NAME_LEN 20
#define SEX_LEN 10
#define JOB_LEN 20
#define CHARACTER_LEN 20

// 03. Class

// 데이터 은닉 (구조체와 다른 점 -> 얘는 그냥 모든게 public)
// : 클래스 안의 속성과 기능을 선택적으로 숨길 수 있다
// 숨기는 이유 : 자신의 속성과 기능을 다른 영역에서 변경하지 못하도록 해야하는 경우가 있다

// 멤버 접근 지정자
// public : 클래스 내부, 외부 모두 멤버에 접근 가능함  -> 인터페이스 함수
// private : 클래스 내부에서만 멤버에 접근 가능함 -> 보통 멤버 변수
// protected : 기본적으로 클래스 내부 영역에서만 클래스 멤버에 접근 가능하나,
//             상속관계에서는 상위 클래스 멤버에 접근 가능하도록 한다.


// 객체를 붕어빵 틀처럼 찍어낼 수 있으며
// 이들은 서로 상호작용 할 수 있음

class Person {

public:
	// 생성자와 같은 역할, 추후에 배울 예정
	void constructor(const char* name, const char* sex, const char* job, const char* character, int age, bool marriageStatus)
	{
		strcpy_s(this->name, name);
		strcpy_s(this->sex, sex);
		strcpy_s(this->job, job);
		strcpy_s(this->character, character);
		this->age = age;
		this->marriageStatus = marriageStatus;
		// 자신을 가르키는 포인터 (this) : 추후 배울 예정
	}

	void introduce()
	{
		cout << "이름: " << name << endl;
		cout << "성별: " << sex << endl;
		cout << "직업: " << job << endl;
		cout << "성격: " << character << endl;
		cout << "나이: " << age << endl;
		cout << "결혼여부: " << (marriageStatus ? "YES" : "NO") << endl;
	}

	void eat(const char* food)
	{
		cout << name << "은(는) " << food << "를 먹는다" << endl;
	}

	void sleep()
	{
		cout << name << "은(는) 잔다" << endl;
	}

	void drive(const char* destination)
	{
		cout << name << "은(는)" << destination << "으로 운전한다" << endl;
	}

	void write()
	{
		cout << name << "은(는) 책을 쓴다" << endl;
	}

	void read()
	{
		cout << name << "은(는) 책을 읽는다" << endl;
	}

private:
	char name[NAME_LEN];
	char sex[SEX_LEN];
	char job[JOB_LEN];
	char character[CHARACTER_LEN];
	int age;
	bool marriageStatus;
};

int main()
{
	Person player1, player2;

	player1.constructor("미영", "여성", "코딩노예", "고집", 23, false);
	player2.constructor("바보", "남성", "학생", "성실", 23, true);


	player1.introduce();
	player2.introduce();

	player1.eat("마라탕");
}

#include <iostream>
using namespace std;

#define NAME_LEN 20
#define SEX_LEN 10
#define JOB_LEN 20
#define CHARACTER_LEN 20

// 03. Class

// 멤버함수 선언과 정의 분리
// :: (범위 지정 연산자) 사용

class Person {

public:
	void constructor(const char* name, const char* sex, const char* job, const char* character, int age, bool marriageStatus);
	void introduce();
	void eat(const char* food);
	void sleep();
	void drive(const char* destination);
	void write();
	void read();

private:
	char name[NAME_LEN];
	char sex[SEX_LEN];
	char job[JOB_LEN];
	char character[CHARACTER_LEN];
	int age;
	bool marriageStatus;
};

int main()
{
	Person player1, player2;

	player1.constructor("미영", "여성", "코딩노예", "고집", 23, false);
	player2.constructor("바보", "남성", "학생", "성실", 23, true);


	player1.introduce();
	player2.introduce();

	player1.eat("마라탕");
}

void Person::constructor(const char* name, const char* sex, const char* job, const char* character, int age, bool marriageStatus)
{
	strcpy_s(this->name, name);
	strcpy_s(this->sex, sex);
	strcpy_s(this->job, job);
	strcpy_s(this->character, character);
	this->age = age;
	this->marriageStatus = marriageStatus;
	// 자신을 가르키는 포인터 (this) : 추후 배울 예정
}

void Person::introduce()
{
	cout << "이름: " << name << endl;
	cout << "성별: " << sex << endl;
	cout << "직업: " << job << endl;
	cout << "성격: " << character << endl;
	cout << "나이: " << age << endl;
	cout << "결혼여부: " << (marriageStatus ? "YES" : "NO") << endl;
}

void Person::eat(const char* food)
{
	cout << name << "은(는) " << food << "를 먹는다" << endl;
}

void Person::sleep()
{
	cout << name << "은(는) 잔다" << endl;
}

void Person::drive(const char* destination)
{
	cout << name << "은(는)" << destination << "으로 운전한다" << endl;
}

void Person::write()
{
	cout << name << "은(는) 책을 쓴다" << endl;
}

void Person::read()
{
	cout << name << "은(는) 책을 읽는다" << endl;
}