📌 [1] Hello World!
Q001. "Hello world!"
/*
* 문제 Q001 : C++ 프로그래밍 시작하기
* 학습 내용 : 콘솔창에 cout을 이용해 원하는 문자열을 출력하면서 C++ 프로그래밍을 시작합니다.
* 힌트 내용 : 코딩이란 무엇인지 이해합니다.
*/
#include <iostream>
using namespace std;
int main()
{
cout << "Hello C++ World!" << endl;
return 0;
}
/*
1. #include <iostream>
cout 사용을 위한 라이브러리 <iostream>을 include
2. using namespace std;
using namespace : 줄임말 사용 선언
std(standard)의 정보들을 사용하겠다.
이후, std에서 제공하는 정보들(cout등)을 사용하기 위해서 std::cout을 cout만 써줘도 된다. 매번 붙여줘야할 std::를 생략가능.
'스코프 설정 연산자(::)'
std::cout << "Hello C+_+ World!" << std::endl;
3. int main(){ ... }
main함수는 프로그램의 시작과 끝을 의미하는 함수. 그러므로 하나의 main함수만 존재할 수 있다.
4. cout << 문자열
명령프롬프트에 출력
5. << endl
end line. 엔터와 같은 역할. 개행 효과.
6. return 0;
검퓨터에게 프로그램 종료 알림. 적지 않으면 프로그램 종료 안된다.
*/
/*
* 출력 결과
Hello C++ World!
*/Q002. cin
/*
* 문제 Q002 : 콘솔창에 출력하기 (cout, cin, endl)
* 학습 내용 : 콘솔창에 원하는 문자열을 출력합니다.
* 힌트 내용 : cout은 출력, cin은 입력받기, endl은 개행입니다.
*/
#include <iostream>
using namespace std;
int main()
{
int number = 0;
cin >> number;
cout << "입력한 숫자는 : " << number << "입니다." << endl;
return 0;
}
/*
1. int number = 0;
정수형 변수 number 선언하고, 0으로 값 초기화.
2. cin >> number
콘솔창을 통해 사용자의 입력값을 변수에 입력받는 함수
변수 number에 입력값 대입, >>방향은 cout과 반대.
cin >> 변수;
*/
/*
* 출력 결과
37
입력한 숫자는 : 37입니다.
*/Q003. x
/*
* 문제 Q003 : 변수 배우기
* 학습 내용 : 값을 저장할 수 있는 변수 개념을 이해합니다.
* 힌트 내용 : 수학 방정식 'y = x+1'의 경우 x와 y를 변수라고 합니다.
*/
#include <iostream>
using namespace std;
int main()
{
int one = 1;
int two = 2;
int sum = one + two;
cout << "1+2=" << sum << endl;
return 0;
}
/*
* 출력 결과
1+2=3
*/Q004. const
/*
* 문제 Q004 : 상수 배우기 (const)
* 학습 내용 : 상수를 이해하고 사용하는 방법을 배웁니다.
* 힌트 내용 : 변하지 않고 변할 수 없는 값을 상수라고 합니다.
*/
#include <iostream>
using namespace std;
int main()
{
const int CHRISTMAS_DAY = 1225; //@상수형 변수 선언
const int HAPPY_NEW_YEAR = 101;
cout << "크리스마스는 " << CHRISTMAS_DAY << "이고 새해시작일은 " << HAPPY_NEW_YEAR << "입니다." << endl;
return 0;
}
/*
1. 상수형 변수
프로그램이 시작하고 종료될 때까지 단 한 번만 초기화됩니다. 프로그램이 종료되기 전까지 상수의 값은 변할 수 없습니다.
만약 상수에 다른 값을 할당하면 다음과 같은 에러가 발생합니다.
'식이 수정할 수 있는 lvalue여야 합니다.'
lvalue : Left value ; 값을 할당 받아야 할 변수
변하지 않을 상수형 변수를 최대한 확보하여 코드를 최적화 한다.
2. 상수형 변수 이름 짓기
2.1. 구글에서 권장하는 이름 규칙
앞에 소문자 k를 붙이기
예) kPI, kMyCountry, kSize
2.2. 보편적인 규칙
대문자와 언더바(_)를 사용한 이름
예) PI, MY_COUNRTY, SIZE
*/
/*
* 출력 결과
크리스마스는 1225이고 새해시작일은 101입니다.
*/
Q006. +=, -=, *=, /=
/*
* 문제 Q006 : 사칙연산 축약하기 (+, -, *, /)
* 학습 내용 : 앞서 배운 사칙연산을 축약하여 간편하게 사용하는 방법을 이해합니다.
* 힌트 내용 : x = x + 2 라는 식을 x += 2 로 축약할 수 있습니다.
*/
#include <iostream>
using namespace std;
int main()
{
int three = 3;
int seven = 7;
int z1 = 9;
int z2 = z1;
cout << "z1 = 9 : " << z1 << " , z2 = z1 : " << z2 << endl << endl;
//1. 덧셈 축약
z1 = z1 + three;
z2 += three;
cout << "z1 = z1 + three : " << z1 << ", z2 += three : " << z2 << endl;
//2. 뺄셈 축약
z1 = z1 - three;
z2 -= three;
cout << "z1 = z1 - three : " << z1 << " , z2 -= three : " << z2 << endl;
//3. 곱셈 축약
z1 = z1 * seven;
z2 *= seven;
cout << "z1 = z1 * seven : " << z1 << ", z2 *= seven : " << z2 << endl;
//4. 나눗셈 축약
z1 = z1 / 5;
z2 /= 5;
cout << "z1 = z1 / 5 : " << z1 << ", z2 /= 5 : " << z2 << endl;
}
/*
1. 사칙 연산 축약
a += 3 (a = a + 3)
b -= 3
c *= 3
d /= 3
*/
/*
* 출력 결과
z1 = 9 : 9 , z2 = z1 : 9
z1 = z1 + three : 12, z2 += three : 12
z1 = z1 - three : 9 , z2 -= three : 9
z1 = z1 * seven : 63, z2 *= seven : 63
z1 = z1 / 5 : 12, z2 /= 5 : 12
*/
Q007. 자료형
/*
* 문제 Q007 : 자료형 이해하기 ( char, int, double, bool, string)
* 학습 내용 : C++ 에서 사용하는 자료형들
* 힌트 내용 : 주로 사용하는 5개의 자료형을 알아봅니다.
*/
#include <iostream>
using namespace std;
int main()
{
int integer = 305;
double precision = 3.14159; //float : 소수점이하 6자리. 웬만하면 15자리인 double형을 쓴다.
//Double-precision : 배정밀도(64bit) (float : Single-precision, 32bit)
char character = 'C';
string word = "Hello World !";
bool is_true = true;
bool its_false = false;
cout << "정수형 - int : " << integer << endl;
cout << "실수형 - double : " << precision << endl;
cout << "문자형 - char : " << character << endl;
cout << "문자열 - string : " << word << endl;
cout << "논리형 - bool : " << is_true << endl;
cout << "논리형 - bool : " << its_false << endl;
return 0;
}
/*
1. 실수형 자료형 double 과 float 의 차이
소수점 제한이 적인 double을 사용하는 것이 좋다.
double : 소수점이하 15자리 ; Double-precision(배정밀도; 64bit)
float : 소수점 이하 6자리 ; Single-prescision(32bit)
2. 문자형 변수(char) 과 문자열 변수(string)
char : 하나의 문자만 저장 가능, 쿼테이션(')을 문자 앞뒤에 붙여 문자의 시작과 끝을 설정한다.
string : 문자가 모인 문자열 : 원하는 숫자, 문자, 특수문자를 섞어 더블 쿼테이션(")을 문자열 앞뒤에 붙여 문자열의 시작돠 끝을 설정한다.
*/
/*
* 출력 결과
정수형 - int : 305
실수형 - double : 3.14159
문자형 - char : C
문자열 - string : Hello World !
논리형 - bool : 1
논리형 - bool : 0
*/Q008. if ~ else
/*
* 문제 Q008 : 조건문 배우기(if ~ else)
* 학습 내용 : 어떤 조건에서 참과 거짓을 판단하는 방법을 이해합니다.
* 힌트 내용 : 참과 거짓 판정을 위해 if ~ else 를 사용합니다.
*/
#include <iostream>
using namespace std;
int main()
{
int x = 3;
int y = 7;
cout << "x : " << x << ", y : " << y << endl;
if (x > y)
cout << "x는 y보다 큽니다." << endl;
else
cout << "x는 y이하 입니다." << endl;
return 0;
}
/*
1. 조건문(if ~ else)의 사용 형식
if (조건)
[ 참 실행 ]
else
[ 거짓 실행 ]
*/
/*
* 출력 결과
x : 3, y : 7
x는 y이하 입니다.
*/Q009. for
/*
* 문제 Q009 : 순환문 배우기(for)
* 학습 내용 : 일정 범위 한에서 같은 동작을 반복하는 for 문을 이해합니다.
* 힌트 내용 : 반복 과정에선 for 문을 주로 사용합니다.
*/
#include <iostream>
using namespace std;
int main() {
int result = 0;
for (int i = 0; i < 5; i++) //for문 내부에서 선언 가능
{
result += i;
cout << "[ index = " << i << " ]" << endl;
cout << "result = " << result << "\n" << endl;
}
cout << "===================" << endl;
cout << "final result : " << result << endl;
return 0;
}
/*
1. for ( ; ; ) 문의 형식
for([i 초기화]; [i 조건]; [i 증감문])
2. for 문의 실행 조건
for([조건])
[실행문]
: [조건]을 만족할 때만 실행.
예)
for( i = 0 ; i < 5; i++)
result += i
: i = 0 -> 1 -> ... -> 4
: 조건(i<5) 을 만족할 때만 실행.
: result : 0 + 1 + 2 + 3 + 4 = 10
*/
/*
* 출력 결과
[ index = 0 ]
result = 0
[ index = 1 ]
result = 1
[ index = 2 ]
result = 3
[ index = 3 ]
result = 6
[ index = 4 ]
result = 10
===================
final result : 10
*/Q010. [ ]
/*
* 문제 Q010 : 배열 배우기([크기])
* 학습 내용 : 같은 자료형 데이터를 여러 개 저장하는 방법을 배웁니다.
* 힌트 내용 : 각괄호[ ]를 사용해 개수를 지정합니다.
*/
#include <iostream>
using namespace std;
int main()
{
const int MY_ARRAY_SIZE = 3;
int myArray[MY_ARRAY_SIZE]; //[3] : index = 0~2까지 길이3의 배열 myArray 생성
cout << "myArray size : " << MY_ARRAY_SIZE << endl << endl;
myArray[0] = 1;
myArray[1] = 22;
myArray[2] = 333;
cout << "myArray[0] : " << myArray[0] << endl;
cout << "myArray[1] : " << myArray[1] << endl;
cout << "myArray[2] : " << myArray[2] << endl << endl;
cout << "myArray[MY_ARRAY_SIZE] : " << myArray[0] << myArray[1] << myArray[2] << endl;
return 0;
}
/*
1. 배열의 [크기]와 [인덱스]
array[크기N] -> 0 ~ N-1 까지 생성.
*/
/*
* 출력 결과
myArray size : 3
myArray[0] : 1
myArray[1] : 22
myArray[2] : 333
myArray[MY_ARRAY_SIZE] : 122333
*/
Q011. function( )
/*
* 문제 Q011 : 함수 배우기 ( () )
* 학습 내용 : 함수는 어떤 목적을 이유로 구현하는 코드 집합입니다.
* 힌트 내용 : 기능별로 분리하여 사용합니다.
*/
#include <iostream>
using namespace std;
int func_Plus(const int x, const int y) //인자값이 변하지 않도록 const 로 선언
{
int z = x + y;
return z;
}
void func_MinusPrint(const int x, const int y) //반환값이 없는 함수의 반환형은 void 로 선언
{
int z = x - y;
cout << "x(" << x << ") - y(" << y << ") = " << z << endl;
//반환값이 없는 함수이므로 return 문 없다.
}
int main()
{
int a = 7;
int b = 3;
cout << "x(" << a << ") + y(" << b << ") = " << func_Plus(a, b) << endl;
func_MinusPrint(a, b);
return 0;
}
/*
1. 함수 선언 형식
[반환형] [함수이름] ([인자 변수])
{
[실행문]
return [반환값];
}
A. 인자 변수 : 값이 변하지 않도록 const int x 로 상수화 선언
B. 반환형 (return) : 반환값 없이 기능만 실행하는 경우 : 반환형 = void
*/
/*
* 출력 결과
x(7) + y(3) = 10
x(7) - y(3) = 4
*/Q013. namespace
/*
* 문제 Q013. 네임스페이스 배우기(namespace)
* 학습 내용 : 같은 이름의 함수, 변수 충돌 문제를 피하기 위해 만들어진 일종의 사전 namespace 를 배웁니다.
* 힌트 내용 : 변수, 함수 범위를 제한합니다.
*/
#include <iostream>
// 1. 내장 namespace 사용 선언
using namespace std;
// 2. 새로운 namespace 선언
namespace monalisa
{
int year = 1503; // 다른 namespace와 겹치는 것
void func_Artist() // 겹치지 않는 것
{
cout << "모나리자 제작자 : 레오나르도 다 빈치" << endl;
}
}
namespace sunflowers
{
int year = 1888; // 다른 namespace와 겹치는 것
}
// 3. nammspace 사용 선언
using namespace monalisa;
using namespace sunflowers;
int main()
{
// 4.1. 겹치는 것(year)은 스코프 설정 연산자(::) 필요
cout << "모나리자 제작연도 : " << monalisa::year << endl;
cout << "해바라기 제작연도 : " << sunflowers::year << endl;
// 4.2. 겹치지 않는 것은 스코프 설정 연산자(::) 불필요
func_Artist(); //monalisa::func_Artist()
return 0;
}
/*
1. namespace 사용 특징
A. 겹치지 않는 변수, 함수는 ::없이 사용 가능.
B. 동일한 이름의 겹치는 변수, 함수는 ::사용하여 'namespace::var' 방식으로 사용해야 함.
C. 스코프 설정 연산자(::)
*/
/*
* 출력 결과
모나리자 제작연도 : 1503
해바라기 제작연도 : 1888
모나리자 제작자 : 레오나르도 다 빈치
*/Q014. #include
/*
* 문제 Q014 : #include 배우기
* 학습 내용 : 다양한 기능을 사용하기 위해 라이브러리 참조 방법을 배웁니다.
* 힌트 내용 : 미리 작성된 코드를 참조하여 사용합니다.
*/
#include <iostream>
//1. 벡터 사용 라이브러리 : C++ 표준 라이브러리
#include <vector>
using namespace std;
int main()
{
//int형 벡터 생성
vector<int> my_vector;
//push_back( n ) 함수 : 백터 맨 뒤에 데이터(n) 삽입
my_vector.push_back(10);
my_vector.push_back(20);
my_vector.push_back(30);
my_vector.push_back(40);
//pop.back() 함수 : 백터 맨 뒤의 데이터를 삭제
my_vector.pop_back();
for (int i = 0; i < my_vector.size(); i++)
{
//at( i ) 함수 : i 번째 값 반환
cout << "마이_벡터 " << i << "번째 값 : " << my_vector.at(i) << endl;
}
return 0;
}
/*
1. 라이브러리 참조 형식
1.1. C++ 내장 표준 라이브러리를 참조하는 경우
#include <라이브러리>
1.2. 사용자가 만든 라이브러리를 참조하는 경우
#include "라이브러리"
*/
/*
* 출력 결과
마이_벡터 0번째 값 : 10
마이_벡터 1번째 값 : 20
마이_벡터 2번째 값 : 30
*/Q015. 스코핑룰
/*
* 문제 Q015 : 스코핑룰 이해하기( {} )
* 학습 내용 : 변수를 사용하기 위한 규칙으로 변수의 유효 범위를 의미합니다.
* 힌트 내용 : 같은 이름의 변수라도 영역에 따라 값이 달라질 수 있습니다.
*/
#include <iostream>
using namespace std;
// 1. 전역변수 : 프로그램 어디서나 접근할 수 있는 변수; super_X
int super_X = 305;
int planet_1()
{
// 2. 외부의 변수(전역변수; super_X)를 참조
return super_X;
}
int planet_2()
{
int super_X = 777;
return super_X;
}
int main()
{
cout << "[ 1st super_X ]" << endl;
cout << ": 전역변수의 영향" << endl;
cout << "super_X of Universe = " << super_X << endl; // 305
cout << "super_X of planet_1 = " << planet_1() << endl; // 305
cout << "super_X of planet_2 = " << planet_2() << " ; 함수내부에서, 함수변수 > 전역변수" << endl << endl; // 777
cout << "[ 2nd super_X ]" << endl;
cout << ": 함수 내부 변수의 영향" << endl;
cout << "super_X of Universe = " << super_X << " ; 전역변수는 함수변수의 영향을 받지 않는다. " << endl; // 305
cout << "super_X of planet_1 = " << planet_1() << endl << endl; // 305
int super_X = 333;
cout << "[ 3rd super_X ]" << endl;
cout << ": main 변수의 영향" << endl;
cout << "* super_X of Earth = " << super_X << " ; main 변수 선언 " << endl; // 333
cout << "super_X of Universe = " << super_X << " ; main 내부에서, main 변수 > 전역변수 " << endl; // 333
cout << "super_X of planet_1 = " << planet_1() << " ; 전역변수는 main 변수의 영향을 받지 않는다. " << endl; // 305
cout << "super_X of planet_2 = " << planet_2() << " ; 함수변수는 main 변수의 영향을 받지 않는다. " << endl; // 777
cout << " Super_X of Earth = " << super_X << " ; main 변수는 함수변수의 영향을 받지 않는다. " << endl << endl; // 333
cout << "[ 스코핑룰 ]" << endl;
cout << "1. 함수변수와 전역변수는 이름이 같을 수 있다. (같은 이름의 변수로 공존할 수 있다.)" << endl;
cout << "2. 함수변수는 전역변수에 영향을 주지 못한다." << endl;
cout << "3. 함수내부에서, 함수변수 > 전역변수로 우선순위를 갖는다." << endl;
cout << "4. 특정 함수변수는 다른 함수변수에 영향을 주지 못한다." << endl;
return 0;
}
/*
1. 스코핑룰
어떤 변수든 변수가 유효한 공간이 존재하며, 이러한 영역을 scope라고 한다.
이러한 유효 범위를 제한하여 사용하는 것을 '스코핑룰'이라고 부른다.
변수와 함수가 많아지며 프로그램 규모가 커질수록 이러한 스코핑룰을 잘 지키는 것이 중요하다.
A. 함수변수와 전역변수는 이름이 같을 수 있다. (같은 이름의 변수로 공존할 수 있다.)
B. 함수변수는 전역변수에 영향을 주지 못한다.
C. 함수내부에서, 함수변수 > 전역변수로 우선순위를 갖는다.
D. 특정 함수변수는 다른 함수변수에 영향을 주지 못한다.
*/
/*
* 실행 결과
[ 1st super_X ]
: 전역변수의 영향
super_X of Universe = 305
super_X of planet_1 = 305
super_X of planet_2 = 777 ; 함수내부에서, 함수변수 > 전역변수
[ 2nd super_X ]
: 함수 내부 변수의 영향
super_X of Universe = 305 ; 전역변수는 함수변수의 영향을 받지 않는다.
super_X of planet_1 = 305
[ 3rd super_X ]
: main 변수의 영향
* super_X of Earth = 333 ; main 변수 선언
super_X of Universe = 333 ; main 내부에서, main 변수 > 전역변수
super_X of planet_1 = 305 ; 전역변수는 main 변수의 영향을 받지 않는다.
super_X of planet_2 = 777 ; 함수변수는 main 변수의 영향을 받지 않는다.
Super_X of Earth = 333 ; main 변수는 함수변수의 영향을 받지 않는다.
[ 스코핑룰 ]
1. 함수변수와 전역변수는 이름이 같을 수 있다. (같은 이름의 변수로 공존할 수 있다.)
2. 함수변수는 전역변수에 영향을 주지 못한다.
3. 함수내부에서, 함수변수 > 전역변수로 우선순위를 갖는다.
4. 특정 함수변수는 다른 함수변수에 영향을 주지 못한다.
*/📌 [2] 자료형
Q016. char
/*
* 문제 Q016 : 문자형 변수 이해하기 (char)
* 학습 내용 : 하나의 문자만 저장하는 자료형 char 을 이해합니다.
* 힌트 내용 : char 는 문자와 숫자를 저장하여 표현할 수 있습니다.
*/
#include <iostream>
using namespace std;
int main() {
// 1. 문자 저장 : '문자'
char ch1 = 'c';
// 2. 문자 저장 : '아스키 코드'
char ch2 = 99; // 'c' == 99
// 3.1. signed : -128 ~ +127
char ch3 = 200; // 보수 : -128 + 200-(127+1) = -56 ; 해당하는 아스키코드 존재하지 않으므로 ? 출력
// 3.2. unsigned : 0 ~ +255
unsigned char ch4 = 200; // 200에 해당하는 아스키코드 존재하지 않으므로? 출력
printf("char ch1 = %c, %d \n", ch1, ch1); // 'c', 99
printf("char ch2 = %c, %d \n", ch2, ch2); // 'c', 99
printf("char ch3 = %c, %d \n", ch3, ch3); // ?, -56
printf("char ch4 = %c, %d \n", ch4, ch4); // ? , 200
return 0;
}
/*
1. char
문자형을 저장하는 1Byte 자료형
1Byte == Data(7) + ECC(1) [bit]
1. 아스키 코드
char 자료형은 아스키 코드 값에 따라 숫자로 값을 할당할 수 있다.
2. signed 와 unsigned
char :
(signed) char : -128 ~ +127
unsigned char : 0 ~ 255
*/
/*
* 실행결과
char ch1 = c, 99
char ch2 = c, 99
char ch3 = ? -56
char ch4 = ? 200
*/Q017. string
/*
* 문제 Q017 : 문자열형 변수 이해하기 (string)
* 학습 내용 : C++ 에서 문자열 변수를 선언하여 사용하는 방법에 대해 배웁니다.
* 힌트 내용 : 문자열은 string 변수로 사용하는 편이 효율적입니다.
*/
// 1. 문자열을 사용하기 위해 string 표준 헤더 추가
# include <string>
# include <iostream>
using namespace std;
int main()
{
// 2. 문자열 선언
string singer = "Dean";
string song = "Come Over";
// 3. 문자열 병합
string music = singer + " - " + song; // 문자열 병합은 문자열끼리만 성립한다. 문자형 '-'병합은 오류 발생
cout << "My favorite song is " << music << endl;
return 0;
}
/*
1. 문자열 string
string 표준 헤더 필요
C++ 에서도 C 에서 처럼 char[]배열을 사용한 문자열을 구성할 수 있으나,
string 을 사용하는 것이 보다 능동적으로 문자열을 다룰 수 있다.
2. 문자열 병합 +
문자열 끼리 +를 사용해 직관적인 문자열 병합이 가능하다.
단, 문자형 'char'형은 병합할 수 없으므로, 한 글자만 병합하더라도 문자열 "a"로 묶어줘야 한다.
문자형 '-'병합은 오류 발생 : singer + '-' + song
*/
/*
* 출력 결과
My favorite song is Dean - Come Over
*/Q018. int
/*
* 문제 Q018 : 정수형 변수 이해하기 (int)
* 학습 내용 : 정수형 자료를 이해하고 사용하는 방법을 배웁니다.
* 힌트 내용 : -1, 0, 1 등을 정수라고 하며 int 키워드로 선언합니다.
*/
#include <iostream>
using namespace std;
int main()
{
// 1.1. 양/음 정수 선언
int posNum = 333;
int negNum = -1000;
// 1.2. 문자를 이용한 아스키 코드 숫자 선언
int asciiNum = 'A'; // 65
cout << posNum << negNum << -asciiNum << endl;
return 0;
}
/*
* 출력결과
333-1000-65
*/Q019. double
/*
* 문제 Q019 : 실수형 변수 이해하기 (double)
* 학습 내용 : 실수형 자료를 이해하고 사용하는 방법을 배웁니다.
* 힌트 내용 : 실수는 double 키워드로 선언합니다.
*/
#include <iostream>
using namespace std;
int main()
{
// 1. double 형 실수 (8Byte)
double pi = 3.14;
// 2. float 형 실수 (4Byte)
float pi_f = 3.14f;
cout << pi << pi_f << endl;
return 0;
}
/*
1. double 과 float
double : 8Byte ,15자리
float :4Byte, 7자리
float 형 선언에서는 값 뒤에 f를 붙여야한다. 컴퓨터는 실수를 기본적으로 8Byte로 생각하기 때문이다.
둘 다 사용하면 오버/언더 플로우 문제가 생길 수 있으므로,
실수는 double 형을 쓰는 것이 좋다.
*/
/*
* 출력 결과
3.143.14
*/Q020. bool
/*
* 문제 Q002 : 논리형 변수 이해하기 (bool)
* 학습 내용 : 참과 거짓을 나타내는 true, false 를 배웁니다.
* 힌트 내용 : 특정 조건을 만족하면 true, 그렇지 않으면 false 입니다.
*/
#include <iostream>
using namespace std;
int main(){
int x = 3;
int y = 7;
bool isTrue = false;
if (x > y) { //false
isTrue = true;
}
else {
isTrue = false;
}
cout << isTrue << endl;
return 0;
}
/*
1. 논리형 변수와 정수값
true : 1
false : 0
2. 논리형 변수의 출력값
정수값으로 변환되어 출력된다.
*/
/*
* 출력결과
0
*/📌 [3] 연산자
Q021. =
/*
* 문제 Q021 : 대입 연산자 이해하기 (=)
* 학습 내용 : 변수에 값을 할당하기 위해 대입 연산자를 사용합니다.
* 힌트 내용 : 등호(=) 연산자를 사용합니다.
*/
#include <iostream>
using namespace std;
int main() {
int x = 3;
int y = 7;
int z = x + y;
cout << z << endl;
return 0;
}
/*
1. L-value
등호(=)를 기준으로 우측값을 좌측으로 대입한다.
이때 좌측의 대입받는 변수를 L-value 라고 부른다.
한편, 값을 변경할 수 없는 상수는 L-value 가 될 수 없습니다.
L-value 는 할당 값을 계속 바꿀 수 있다.
*/
/*
* 출력 결과
10
*/Q022. +, -
/*
* 문제 q022 : 부호 연산자 이해하기 (+, -)
* 학습 내용 : 수학에서 사용하는 부호의 의미와 똑같다는 것을 이해합니다.
* 힌트 내용 : 부호 연산자는 +, - 를 이용합니다.
*/
#include <iostream>
using namespace std;
int main() {
int x = 1;
int y = 2;
int z = -3;
cout << x + y + z << endl;
return 0;
}
/*
* 출력 결과
0
*/Q023. ++, --
/*
* 문제 Q023 : 증감 연산자 이해하기 (++, --)
* 학습 내용 : +1 또는 -1을 수행하는 증감 연산자를 이해합니다.
* 힌트 내용 : 부호 연산자와 증감 연산자는 다른 의미입니다.
*/
#include <iostream>
using namespace std;
int main() {
int x = 1;
cout << "x = " << x++ << endl; // 1
cout << "x = " << ++x << endl; // 3
cout << "x = " << x++ << endl; // 3
cout << "x = " << x-- << endl; // 4
cout << "x = " << --x << endl; // 2
cout << "x = " << x << endl; // 2
cout << "x = " << x << endl; // 2
return 0;
}
/*
* 출력 결과
x = 1
x = 3
x = 3
x = 4
x = 2
x = 2
x = 2
*/Q024. ==, !=, <, <=, >, >=
/*
* 문제 Q024 : 관계 연산자 이해하기 (==, !=, <, <= , >, >=)
* 학습 내용 : 두 값이 같은지, 다른지, 큰지, 이상인지, 작은지, 이하인지 비교하는 방법을 이해합니다.
* 힌트 내용 : 두 값을 비교할 땐 6가지 비교 조건을 사용할 수 있습니다.
*/
#include <iostream>
using namespace std;
int main() {
int x = 3;
int y = 7;
cout << (x == y) << endl; // 0
cout << (x != y) << endl; // 1
cout << (x < y) << endl; // 1
cout << (x <= y) << endl; // 1
cout << (x > y) << endl; // 0
cout << (x >= y) << endl; // 0
return 0;
}
/*
* 출력 결과
0
1
1
1
0
0
*/Q025. &&, ||, !
/*
* 문제 Q025 : 논리 연산자 이해하기 (and(&&), or(||), not(!))
* 학습 내용 : 두개의 값 또는 두 개 이상의 조건을 비교하는 방법을 이해합니다.
* 힌트 내용 : 공학에서 사용하는 의미와 똑같습니다.
*/
#include <iostream>
using namespace std;
int main() {
int x = 3;
int y = 7;
bool lie = false;
cout << (x == 7 && y == 7) << endl; // 0
cout << (x == 7 || y == 7) << endl; // 1
cout << (x != 7 ) << endl; // 1
cout << !(lie) << endl; // 1
return 0;
}
/*
1. NOT(!)
논리형 변수 앞에 !를 붙이면 == false 와 같은 뜻이다.
if(x == false)
if( !x )
*/
/*
* 출력 결과
0
1
1
1
*/Q026. - ? - : -
/*
* 문제 Q026 : 조건부 삼항 연산자 이해하기 ( ? : )
* 학습 내용 : 간단한 if 문을 한 줄로 대체할 수 있는 조건부 삼항 연산자를 이해합니다.
* 힌트 내용 : if ~ else 대신 ? : 을 사용합니다.
*/
#include <iostream>
using namespace std;
int main() {
int x = 3;
int y = 7;
bool result = false;
bool result2 = false;
// 1. 삼항 연산자
result = x < y ? true : false;
// 2. if 조건문
if (x < y)
result2 = true;
else
result2 = false;
cout << result << +result2 << endl;
return 0;
}
/*
1. 삼항 연산자
? : 의 형식을 사용하여 if 조건문을 한 줄로 축약할 수 있다.
(조건) ? (참일때의 반환값) : (거짓일 때의 반환값)
2. if 문의 삼항 연산자 변형
if(조건)
result = 참인 경우의 반환값
else
result = 거짓인 경우의 반환값
아래의 삼항 연산자로 축약할 수 있다.
result = (조건) ? (참반환값) : (거짓반환값)
*/
/*
* 출력 결과
11
*/Q027. ,
/*
* 문제 Q027 : 쉼표 연산자 이해하기 (,)
* 학습 내용 : 연속되는 코드를 이어 붙이는데 쉼표 연산자(,)가 사용됩니다.
* 힌트 내용 : , 연산자를 사용할 수 있습니다.
*/
#include <iostream>
using namespace std;
int main() {
// 1. 변수 선언 이어 붙이기
int x = 3, y = 7;
int z = 0;
//2. 실행문 이어 붙이기
z = x + y, y++;
cout << z << y << endl;
return 0;
}
/*
1. 쉼표 연산자 활용 유의
아래와 같은 양식으로 쉼표 연산자를 사용할 수는 없다.
1.1. 변수들에 한번에 같은 값 대입
int a, b, c = 1; // 오류
1.2. 변수들 각각에 다른 값 대입
int a, b, c == 1, 2, 3 //오류
*/
/*
* 출력 결과
108
*/Q028. &, |, ^, ~, <<, >>
/*
* 문제 Q028 : 비트 연산자 이해하기 (&, |, ^, ~, <<, >>)
* 학습 내용 : 컴퓨터가 이해하는 비트 단위 연산을 이해합니다.
* 힌트 내용 : 컴퓨터는 0과 1, 두 개 신호로 동작합니다.
*/
#include <iostream>
// 1. bitset 컨테이너를 사용
#include <bitset>
using namespace std;
int main() {
bitset<8> bitX;
bitX.reset(); // 0000 0000
bitX = 127; // 0111 1111
bitset<8> bitY;
bitY.reset();
bitY = 0x37; // 0011 0111 == 16*3 + 1*7 == 55
bitset<8> bit1 = bitX & bitY; // 0011 0111
bitset<8> bit2 = bitX | bitY; // 0111 1111
bitset<8> bit3 = bitX ^ bitY; // 0100 1000
bitset<8> bit4 = ~bitX; // 1000 0000
bitset<8> bit5 = bitY << 1; // 0110 1110
bitset<8> bit6 = bitY >> 3; // 0000 0110
cout << bit1 << ", " << bit1.to_ulong() << endl;
cout << bit2 << ", " << bit2.to_ulong() << endl;
cout << bit3 << ", " << bit3.to_ulong() << endl;
cout << bit4 << ", " << bit4.to_ulong() << endl;
cout << bit5 << ", " << bit5.to_ulong() << endl;
cout << bit6 << ", " << bit6.to_ulong() << endl;
}
/*
1. 비트 연산자 : 논리 연산자
AND) a&b : A&&B
OR ) a|b : A||B
XOR) a^b : -
NOT) ~a : !A (~ : 비트반전)
2. Shift 에서의 새로 채우는 영역
bit Shift에서 새로 채우는 영역은 0으로 채워진다.
x = 1111 1111
x >> 3 // 0001 1111
x << 3 // 1111 1000
*/
/*
* 출력 결과
00110111, 55
01111111, 127
01001000, 72
10000000, 128
01101110, 110
00000110, 6
*/
// 1. 비트 연산에는 bitset 컨테이너를 사용하는 것이 수월하다. Q162~164에서 다룬다.Q029. static_cast< >
/*
* 문제 Q029 : 캐스트 연산자 이해하기 (static_cast< >)
* 학습 내용 : 어떤 자료형을 다른 자료형으로 변경하는 방법을 이해합니다.
* 힌트 내용 : 자료형 변환을 'Type Cast'라 합니다.
*/
#include <iostream>
using namespace std;
int main() {
int x = 3;
double pi = 3.14;
// 1. 연산 결과의 형변환 (Type Casting)
int result = static_cast<int>(x * pi); // 9.42 => 9
// 2. C언어 스타일의 전통적인 캐스팅
int resultC = (int)pi / x; // 1.046... => 1
cout << result << resultC << endl;
return 0;
}
/*
1. 자료형 변환 연산자 4가지
1.1. static_cast<자료형>(변수)
가장 기본적인 캐스트 연산 방법
1.2. dynamic_cast<>
객체지향 언어의 다형성을 이용하여 모호한 타임 캐스팅 오류를 막아줌
1.3. const_cast<>
자료형이 갖고 있는 상수 속성을 제거
1.4. reinterpret_cast<>
어떠한 포인터 타입끼리도 변환할 수 있게 도움
2. 전통적인 C 스타일 캐스팅
(자료형)변수
어떤 자료형이든 무조건 변환한다는 문제가 있으므로,
C++ 에서는 사용을 지양할 것을 권장.
*/
/*
* 출력결과
91
*/Q030. int(x)
/*
* 문제 Q030 : 명시적 변환 이해하기 (())
* 학습 내용 : static_cast 을 사용하지 않고 명시적으로 자료형을 변경하는 방법을 이해합니다.
* 힌트 내용 : 자료형 뒤에 괄호()를 붙이고 그 안에 변환하려는 변수를 넣습니다.
*/
#include <iostream>
using namespace std;
int main() {
int x = 83;
double pi = 3.14;
// 1.1. 명시적 변환
// 자료형(변수)
int result1 = int(x / pi);
double result2 = double(x / pi);
// 1.2. 묵시적 변환
int result3 = x / pi;
double result4 = x / pi;
// 1.3. 캐스트 연산자를 이용한 변환
int result5 = static_cast<int>(x / pi);
double result6 = static_cast<double>(x / pi);
// 2. 명시적 변환을 이용한 아스키 코드의 문자 표현
char ch = char(x);
cout << result1 << ", " << result2 << endl;
cout << result3 << ", " << result4 << endl;
cout << result5 << ", " << result6 << endl;
cout << int(ch) << ", " << ch << endl;
return 0;
}
/*
1. 명시적 형변환
자료형을 큰 크기에서 작은 크기로 변환할 때, 데이터를 잘라서 작은 크기의 자료형에 맞춘다.
2. 묵시적 형변환
묵시적 형변환은 C++ 컴파일러가 자동으로 실행해 주는 형변환
데이터의 손실이 최소화되는 방향으로 형변환이 진행된다.
3. 명시적 형변환과 묵시적 형변환의 차이점
결과적인 차이는 없다.
명시적 형변환 : 내부적으로 임시변수를 생성에 대입하는 방식으로 성능 저하를 일으킬 수 있다.
묵시적 형변환 : 데이터 손실에 대한 경고가 발생한다. ('double'에서 'int'(으)로 변환하면서 데이터가 손실될 수 있습니다.)
*/
/*
* 출력 결과
26, 26.4331
26, 26.4331
26, 26.4331
83, S
*/Q031. sizeof( )
/*
* 문제 Q031 : 자료형의 크기 이해하기 (sizeof)
* 학습 내용 : 자료형이나 객체 등이 갖는 메모리 크기를 이해합니다.
* 힌트 내용 : sizeof 연산자를 이용합니다.
*/
#include <iostream>
using namespace std;
// 1. 5Byte Class 생성 (4B + 1B)
class MyClass {
int nothing;
bool is_nothing;
};
int main() {
cout << "size of (int) : " << sizeof(37) << " [Byte]" << endl; // 4
cout << "size of (double) : " << sizeof(3.14) << " [Byte]" << endl; // 8
cout << "size of (char) : " << sizeof('S') << " [Byte]" << endl; // 1
cout << "size of (string) : " << sizeof("Star") << " [Byte]" << endl; // 5 (공백1 + 문자열4)
cout << "size of (class) : " << sizeof(MyClass) << " [Byte]" << endl; // 8
}
/*
1. Class 의 크기
클래스 My Class 는 5Btye 임에도 8Byte 의 결과가 나왔다.
이는 컴퓨터 프로세서의 '데이터 버스'와 관련이 있다.
데이터 버스는 한 번에 4Byte 데이터를 담아 이동한다.
그래서 4Byte 단위로 몇 번 움직이느냐에 따라 sizeof 의 결과가 달라진다.
=> My Class : 4Byte 버스 2번 이동하여 8Byte 결과.
@시스템 버스
CPU, 메모리, 입력 장치, 출력 장치들 끼리 데이터를 주고 받을 수 있도록 돕는다.
버스는 동기식/비동기식으로 나뉜다.
동기식 : 속도가 빠르지만 CLK 주기를 맞추는 과정에서 쓸모없는 시간이 흐른다.
비동기식 : 핸드 쉐이크 등으로 속도가 느리지만, 주고 받을 준비만 되면 언제든 송수신이 가능해서 효율적 시간 사용이 가능하다.
*/
/*
* 출력 결과
size of (int) : 4 [Byte]
size of (double) : 8 [Byte]
size of (char) : 1 [Byte]
size of (string) : 5 [Byte]
size of (class) : 8 [Byte]
*/📌 [4] 조건문
Q032. if ~ else if ~ else
/*
* 문제 Q032 : 중첩 조건문 이해하기 (if ~ else if ~ else)
* 학습 내용 : if 문의 조건을 여러 번 두는 중첩 사용 방법을 이해합니다.
* 힌트 내용 : if 와 else 사이에 else if 를 추가합니다.
*/
#include <iostream>
using namespace std;
int main() {
int x = 3;
int y = 7;
if (x > y)
cout << "x가 더 큽니다." << endl;
else if (x < y)
cout << "y가 더 큽니다." << endl;
else
cout << "x와 y가 같습니다." << endl;
return 0;
}
/*
1. else if 문의 다중 사용
else if 문을 한 번 사용하는 것은 괜찮지만 2,3번 이상 사용하는 것은 지양합니다.
조건문을 일일이 비교하다 보면 Program Counter 가 증가하여 프로그램 성능에도 좋지않고,
가독성도 떨어지기 때문입니다.
- 중첩 조건문의 조건이 2개 이상이라면 switch case 문 사용은 권장합니다.
*/
/*
* 출력 결과
y가 더 큽니다.
*/Q033. 조건문 Q. 가장 큰수 찾기
/*
* 문제 Q033 : 중첩 조건문으로 가장 큰 수 찾기
* 학습 내용 : if 문을 이용하여 가장 큰 수를 찾는 방법을 이해합니다.
* 힌트 내용 : 3개의 정수를 비교하여 가장 큰 정수를 찾습니다.
*/
#include <iostream>
using namespace std;
int main() {
int x = 111;
int y = 333;
int z = 777;
int biggestNumb = 0;
if (x > y && x > z)
biggestNumb = x;
else if (y > x && y > z)
biggestNumb = y;
else if (z > x && z > y)
biggestNumb = z;
else
cout << "같은 값을 갖는 수가 있습니다." << endl;
cout << "가장 큰 수: " << biggestNumb << endl;
return 0;
}
/*
* 출력 결과
가장 큰 수: 777
*/📌 [5] 반복문
Q034. for ~ continue ~ break
/*
* 문제 Q034 : 중첩 순환문 이해하기 (for ~ continue ~ break)
* 학습 내용 : 반복문 사이에 조건을 두어 순환하는 방법을 이해합니다.
* 힌트 내용 : 순환에서 continue 는 건너뛰기, break 는 종료를 의미합니다.
*/
#include <iostream>
using namespace std;
int main() {
int num = 100;
cout << num << "의 약수 :" << endl;
for (int div = 1; div <= 999; div++) {
if (num % div != 0)
continue;
else if (div > num)
break;
cout << div << endl;
}
return 0;
}
/*
1. continue 와 break
continue : '건너뛰기' ; 아래코드 실행하지 않고 다음 반복 순서 실행
break : '종료' ; 반복문 종료
*/
/*
* 출력 결과
100의 약수 :
1
2
4
5
10
20
25
50
100
*/Q035. 반복문 Q. 특정 문자 개수 구하기
/*
* 문제 Q035 : 반복문으로 특정 문자 개수 구하기 (for)
* 학습 내용 : 문자열에서 특정 알파벳 개수를 구하는 방법을 이해합니다.
* 힌트 내용 : string 변수의 한 요소는 char 입니다. 알파벳 한 개의 일치 여부는 char 로 비교합니다.
*/
#include <iostream>
#include <string>
using namespace std;
int main() {
string pooh = "You are braver than you believe, stronger than you seem, and smarter than you think.";
char letter = 'a';
// 1. 문자열의 크기로 스캔의 한계값을 구한다.
int poohSize = pooh.size();
int count = 0;
// 2. 문자열은 문자 하나 하나로 이루어진 배열이다.
for (int i = 0; i < poohSize; i++) {
if (pooh[i] == letter)
count++;
}
cout << letter << "의 갯수 : " << count << endl;
return 0;
}
/*
* 출력 결과
a의 갯수 : 7
*/Q036. 반복문 Q. 홀수, 짝수 찾기
/*
* 문제 Q036 : 반복문으로 홀수, 짝수 찾기 (for)
* 학습 내용 : 정수형 배열을 순회하며 홀수, 짝수를 구분하는 방법을 이해합니다.
* 힌트 내용 : 짝수는 2로 나눴을 때 나머지가 0입니다. (% == 0)
*/
#include <iostream>
#include <string>
using namespace std;
int main() {
int data[10] = {1, 5, 12, 23, 35, 36, 89, 32, 235, 2};
string oddEven;
for (int i = 0; i < 10; i++) {
if (data[i] % 2 == 0)
oddEven = "짝";
else
oddEven = "홀";
cout << data[i] << " : " << oddEven << "수 입니다." << endl;
}
return 0;
}
/*
* 출력 결과
1 : 홀수 입니다.
5 : 홀수 입니다.
12 : 짝수 입니다.
23 : 홀수 입니다.
35 : 홀수 입니다.
36 : 짝수 입니다.
89 : 홀수 입니다.
32 : 짝수 입니다.
235 : 홀수 입니다.
2 : 짝수 입니다.
*/Q037. switch ~ case ~ default
/*
* 문제 Q037 : 조건 선택문 이해하기 (switch ~ case ~ default)
* 학습 내용 : 조건 선택문을 사용하는 방법을 이해합니다.
* 힌트 내용 : 중첩 조건문이 길어지면 조건 선택문을 사용합니다.
*/
#include <iostream>
using namespace std;
int main() {
int x = 3;
int y = 7;
int answer;
// 1. case 비교문에서 사용할 값을 받는다.
switch (x*y) {
// 2. switch 에서 받은 값과 case 의 값이 같다면 명령이 실행된다.
case 11:
answer = 11;
// 3. break 라인이 없으면 case 문은 종료되지 않고 아래 라인(case 문)이 실행된다.
break;
case 21:
answer = 21;
break;
case 31:
answer = 31;
break;
// 4. case 어느 것에도 해당하지 않을 때 수행된다.
default:
answer = 0;
break;
}
cout << "답 : " << answer << endl;
return 0;
}
/*
1. switch 문의 사용
switch (사용값){
case 비교값:
실행문
break;
default:
실행문
break;
}
1) case 비교문에서 사용할 값 선언
2) case 비교문에 switch 사용값과 비교할 값 지정
3) 실행문 끝에는 break;
4) switch 문의 끝에는 default: 를 사용하여 향후 유지보수를 용이하도록 한다.
*/
/*
* 출력 결과
답 : 21
*/Q038. while ~ continue ~ break
/*
* 문제 Q038 : 조건 반복문 이해하기 1 (while ~ continue ~ break)
* 학습 내용 : 조건에 맞으면 반복한다는 while 문 사용 방법을 이해합니다.
* 힌트 내용 : for 문은 특정 범위, while 은 특정 조건에서 반복합니다.
*/
#include <iostream>
using namespace std;
int main() {
int x = 3;
int y = 7;
while (x < y) {
x++;
if (x % 2 == 0)
continue;
else
cout << "x = " << x << endl;
}
return 0;
}
/*
* 출력 결과
x = 5
x = 7
*/Q039. do ~ while ~ continue ~ break
/*
* 문제 Q039 : 조건 반복문 이해하기 2 (do ~ while ~ continue ~ break)
* 학습 내용 : 무조건 한 번은 실행한 뒤, 조건이 맞는다면 반복하는 do while 문 사용 방법을 이해합니다.
* 힌트 내용 : 무조건 한 번은 실행한다는 장점과 단점을 갖고 있습니다.
*/
#include <iostream>
using namespace std;
int main() {
int x = 0;
int y = 7;
// 1. 조건에 상관없이 한 번은 무조건 실행한다.
do {
x++;
if (x % 2 == 0)
continue;
else
cout << "x = " << x << endl;
} while (y % x < 5);
// 2. 조건이 참이면 한 번 더 반복 수행한다.
return 0;
}
/*
1. do ~ while 문의 사용 추세
한 번은 꼭 실행되는 것이 장점으로 인식되었는데,
최근에는 한 번 더 수행되는 점 때문에 사용 빈도가 줄어드는 추세입니다.
"무조건 한 번은 실행된다"에서 "한 번 더 실행된다"라고 인식이 바뀐 것입니다.
반복문이 한 번 더 수행되면 벡터와 같은 컨테이너들의 인덱스 문제 등이 있습니다.
그래서 되도록이면 do ~ while 문 대신, 일반 while, for, switch ~ case 문의 사용을 권장합니다.
*/
/*
* 출력 결과
x = 1
x = 3
x = 5
x = 7
*/Q040. 반복문 Q. 구구단 계단형으로 출력하기
/*
* 문제 Q040 : 반복문을 이용하여 구구단(15단) 계단형 출력하기
* 학습 내용 : 반복문을 이용하여 구구단을 계단형으로 출력하는 방법을 이해합니다.
* 힌트 내용 : for 문을 3개 이용해야 합니다.
*/
#include <iostream>
using namespace std;
int main() {
int offset = 0;
for (int i = 1; i <= 15; i += offset) {
offset++;
for (int j = 1; j <= 9; j++) {
for (int k = 0; k < offset; k++) {
cout << i + k << " X " << j << " == " << ((i + k) * j);
cout << "\t";
}
cout << endl;
}
cout << endl;
}
return 0;
}
/*
* 출력 결과
1 X 1 == 1
1 X 2 == 2
1 X 3 == 3
1 X 4 == 4
1 X 5 == 5
1 X 6 == 6
1 X 7 == 7
1 X 8 == 8
1 X 9 == 9
2 X 1 == 2 3 X 1 == 3
2 X 2 == 4 3 X 2 == 6
2 X 3 == 6 3 X 3 == 9
2 X 4 == 8 3 X 4 == 12
2 X 5 == 10 3 X 5 == 15
2 X 6 == 12 3 X 6 == 18
2 X 7 == 14 3 X 7 == 21
2 X 8 == 16 3 X 8 == 24
2 X 9 == 18 3 X 9 == 27
4 X 1 == 4 5 X 1 == 5 6 X 1 == 6
4 X 2 == 8 5 X 2 == 10 6 X 2 == 12
4 X 3 == 12 5 X 3 == 15 6 X 3 == 18
4 X 4 == 16 5 X 4 == 20 6 X 4 == 24
4 X 5 == 20 5 X 5 == 25 6 X 5 == 30
4 X 6 == 24 5 X 6 == 30 6 X 6 == 36
4 X 7 == 28 5 X 7 == 35 6 X 7 == 42
4 X 8 == 32 5 X 8 == 40 6 X 8 == 48
4 X 9 == 36 5 X 9 == 45 6 X 9 == 54
7 X 1 == 7 8 X 1 == 8 9 X 1 == 9 10 X 1 == 10
7 X 2 == 14 8 X 2 == 16 9 X 2 == 18 10 X 2 == 20
7 X 3 == 21 8 X 3 == 24 9 X 3 == 27 10 X 3 == 30
7 X 4 == 28 8 X 4 == 32 9 X 4 == 36 10 X 4 == 40
7 X 5 == 35 8 X 5 == 40 9 X 5 == 45 10 X 5 == 50
7 X 6 == 42 8 X 6 == 48 9 X 6 == 54 10 X 6 == 60
7 X 7 == 49 8 X 7 == 56 9 X 7 == 63 10 X 7 == 70
7 X 8 == 56 8 X 8 == 64 9 X 8 == 72 10 X 8 == 80
7 X 9 == 63 8 X 9 == 72 9 X 9 == 81 10 X 9 == 90
11 X 1 == 11 12 X 1 == 12 13 X 1 == 13 14 X 1 == 14 15 X 1 == 15
11 X 2 == 22 12 X 2 == 24 13 X 2 == 26 14 X 2 == 28 15 X 2 == 30
11 X 3 == 33 12 X 3 == 36 13 X 3 == 39 14 X 3 == 42 15 X 3 == 45
11 X 4 == 44 12 X 4 == 48 13 X 4 == 52 14 X 4 == 56 15 X 4 == 60
11 X 5 == 55 12 X 5 == 60 13 X 5 == 65 14 X 5 == 70 15 X 5 == 75
11 X 6 == 66 12 X 6 == 72 13 X 6 == 78 14 X 6 == 84 15 X 6 == 90
11 X 7 == 77 12 X 7 == 84 13 X 7 == 91 14 X 7 == 98 15 X 7 == 105
11 X 8 == 88 12 X 8 == 96 13 X 8 == 104 14 X 8 == 112 15 X 8 == 120
11 X 9 == 99 12 X 9 == 108 13 X 9 == 117 14 X 9 == 126 15 X 9 == 135
*/Q041. 반복문 Q. 피보나치 수열 출력하기
/*
* 문제 Q041 : 반복문을 이용하여 피보나치 수열 출력하기
* 학습 내용 : 반복문을 이용하여 피보나치 수열을 출력하는 방법을 이해합니다.
* 힌트 내용 : += 를 사용합니다.
*/
#include <iostream>
using namespace std;
int main() {
int x = 0;
int y_temp = 0;
int y = 1;
int freq = 10;
cout << x << ",";
cout << y << ",";
for (int i = 0; i < freq - 2; i++) {
y_temp = y;
y += x;
cout << y << ",";
x = y_temp;
}
return 0;
}
/*
* 출력 결과
0,1,1,2,3,5,8,13,21,34,
*/Q042. 반복문 Q. 피라미드 출력하기
/*
* 문제 Q042 : 반복문을 이용하여 피라미드 출력하기
* 학습 내용 : 반복문을 이용하여 피라미드를 출력하는 방법을 이해합니다.
* 힌트 내용 : for 문 3개, while 문 1개를 이용합니다.
*/
#include <iostream>
using namespace std;
int main() {
int offset = 5;
// 1. i: 0->증가, j: 매 반복마다 0으로 초기화
for (int i = 0, j = 0; i < offset; i++, j = 0) {
for (int k = 0; k < offset - i - 1; k++)
cout << " ";
while (j < 2 * i + 1) {
cout << "*";
j++;
}
cout << endl;
}
return 0;
}
/*
* 내 풀이
int main() {
int floor = 5;
// 1. 지정한 층 수 만큼 반복
for (int i = 0; i < floor; i++) {
// 2. 스페이스 : 낮은 층일 수록 많이. 최초는 실행 안되도록.
for (int j = 0; j < floor - i - 1; j++)
cout << " ";
// 3. 별 : 홀 수 등차수열. 최초 1회
for (int k = 0; k < (2*i + 1); k++) {
cout << "*";
}
cout << endl;
}
return 0;
}
*/
/*
* 출력 결과
*
***
*****
*******
*********
*/📌 [6] 수 처리 함수
Q043. floor( ), ceil( )
/*
* 문제 Q043 : 실수 소수점 버리기 올리기 (floor, ceil)
* 학습 내용 : 소수점을 무조건 버리거나 올리는 방법을 이해합니다.
* 힌트 내용 : floor, ceil 함수를 사용합니다.
*/
#include <iostream>
using namespace std;
int main() {
cout << "1. 소수점 버리기" << endl;
cout << "\t1.1. floor" << endl;
cout << "floor(3.7) : " << floor(3.7) << endl;
cout << "floor(7.373737) : " << floor(7.373737) << endl;
cout << "floor(-3.7) : " << floor(-3.7) << "\n" << endl;
cout << "\t1.2. ceil" << endl;
cout << "ceil(3.7) : " << ceil(3.7) << endl;
cout << "ceil(7.373737) : " << ceil(7.373737) << endl;
cout << "ceil(-3.7) : " << ceil(-3.7) << "\n" << endl;
return 0;
}
/*
1. 소수점 버리기; floor vs ceil
floor : 작아지는 방향으로 버리기
ceil : 증가하는 방향으로 버리기
*/
/*
* 출력 결과
1. 소수점 버리기
1.1. floor
floor(3.7) : 3
floor(7.373737) : 7
floor(-3.7) : -4
1.2. ceil
ceil(3.7) : 4
ceil(7.373737) : 8
ceil(-3.7) : -3
*/Q044. round( )
/*
* 문제 Q044 : 실수 반올림하기 (round)
* 학습 내용 : 소수점을 반올림하는 방법을 이해합니다.
* 힌트 내용 : round 함수를 사용합니다.
*/
#include <iostream>
using namespace std;
int main() {
cout << "round(3.7) : " << round(3.7) << endl;
cout << "round(7.373737) : " << round(7.373737) << endl;
cout << "round(-3.7) : " << round(-3.7) << endl;
cout << "round(-7.3) : " << round(-7.3) << endl;
return 0;
}
/*
1. 음&양수의 반올림 round
음수도 양수처럼 반올림된다.
+1.7 -> 2
-1.7 -> 2
*/
/*
* 출력 결과
round(3.7) : 4
round(7.373737) : 7
round(-3.7) : -4
round(-7.3) : -7
*/Q045. abs( ), fabs( ), pow( )
/*
* 문제 Q045 : 절대값과 제곱수 구하기 (abs, fabs, pow)
* 학습 내용 : 절대값과 제곱수 구하는 방법을 이해합니다.
* 힌트 내용 : abs(), fabs(), pow() 를 사용합니다.
*/
#include <iostream>
using namespace std;
int main() {
cout << "abs(-3) : " << abs(-3) << endl;
cout << "fabs(-3.7) : " << fabs(-3) << endl;
cout << "2^5 ;pow(2, 5) : " << pow(2, 5) << endl;
return 0;
}
/*
1. 절대값
abs(정수) : 정수의 절대값
fabs(실수) : 실수의 절대값
*labs( ) : long 자료형의 절대값
최소 반환값과 최대 표현 값 등이 다르다.
*/
/*
* 출력 결과
abs(-3) : 3
fabs(-3.7) : 3
2^5 ;pow(2, 5) : 32
*/Q046. %
/*
* 문제 Q046 : 몫과 나머지 구하기 (%)
* 학습 내용 : 정수나 실수를 나눴을 때 몫과 나머지를 구하는 방법을 이해합니다.
* 힌트 내용 : 몫은 정수이며 나머지는 실수입니다.
*/
#include <iostream>
using namespace std;
int main() {
// 1. 정수 나눗셈
int x1 = 37;
int y1 = 5;
int quotient1 = static_cast<int>(x1 / y1);
int remainder1 = x1 % y1;
cout << "37 / 5 == " << "몫 : " << quotient1 << ", 나머지 : " << remainder1 << endl;
// 2. 실수 나눗셈
double x2 = 37.3;
int y2 = 5;
int quotient2 = static_cast<int>(x2 / y2);
double remainder2 = x2 - (y2 * quotient2);
cout << "37.3 / 5 == " << "몫 : " << quotient2 << ", 나머지 : " << remainder2 << endl;
// 2.1. 실수 나눗셈에는 나머지 연산자(%)를 사용할 수 없다.
//cout << x2 % y2 << endl; // 에러 발생
return 0;
}
/*
1. 나머지 연산자 (%)
실수 나눗셈에는 사용할 수 없다.
*/
/*
* 출력 결과
37 / 5 == 몫 : 7, 나머지 : 2
37.3 / 5 == 몫 : 7, 나머지 : 2.3
*/Q047. sqrt( )
/*
* 문제 Q047 : 제곱근 구하기 (sqrt)
* 학습 내용 : 제곱근 구하는 방법을 이해합니다.
* 힌트 내용 : sqrt() 함수를 사용합니다.
*/
#include <iostream>
using namespace std;
int main() {
cout << "sqrt(25) : " << sqrt(25) << endl;
cout << "sqrt(37) : " << sqrt(37) << endl;
return 0;
}
/*
* 출력 결과
sqrt(25) : 5
sqrt(37) : 6.08276
*/Q048. modf( )
/*
* 문제 Q048 : 소수점 분리하기 (modf)
* 학습 내용 : 실수를 정수부(몫)와 소수부(나머지)로 나누는 방법을 이해합니다.
* 힌트 내용 : modf() 함수를 사용합니다.
*/
#include <iostream>
using namespace std;
int main() {
double x = 3.7123;
double quotient = 0.0;
double remainder = 0.0;
remainder = modf(x, "ient);
cout << x << endl;
cout << "정수부 : " << quotient << ", 소수부 : " << remainder << endl;
return 0;
}
/*
1. modf() 함수
[소수부] = modf([실수], &[정수부])
정수부 변수(qtnt)의 주소를 넘기므로, 메모리 영역의 실제 값을 변경시킬 수 있다.
qtnt 의 값이 함수내에서 변경돼도, 함수 호출 영역 밖에서도 변경된 값이 유효하게 된다.
*/
/*
* 출력 결과
3.7123
정수부 : 3, 소수부 : 0.7123
*/Q049. srand( ), rand( )
/*
* 문제 Q049 : 난수 생성하기 (srand, rand)
* 학습 내용 : 임의의 수, 난수를 구하는 방법을 이해합니다.
* 힌트 내용 : srand() 와 rand() 함수를 사용합니다.
*/
#include <iostream>
// 0. ctime 라이브러리
#include <ctime>
using namespace std;
int main() {
// 1. srand() : 난수 초기화; seed == 시간
srand(static_cast<unsigned int>(time(NULL)));
// 2. rand() : 무작위 값 생성; by seed
for (int i = 0; i < 5; i++)
cout << i+1 << "번째 난수 : " << rand() << endl;
return 0;
}
/*
1. srand() 와 rand()
난수를 구할 땐 해당 정보를 프로그램 안에서 한 번은 초기화해야 합니다.
이때 난수를 구하기 위해선 seed 값이 필요한데 보통은 시스템 시간을 사용합니다.
seed 를 기준으로 무작위 값이 생성되므로 seed 값은 계속 바뀌어야 합니다.
seed 가 변하지 않는 값이면 매 실행마다 같은 결과가 출력됩니다.
srand (seed) : 난수의 seed 를 심는 과정.
rand() : srand(seed) 에서의 seed 값을 이용해 무작위 값을 반환한다.
*/
/*
* 출력 결과
1번째 난수 : 2729
2번째 난수 : 26341
3번째 난수 : 3114
4번째 난수 : 16095
5번째 난수 : 3557
*/Q050. random_shuffle( )
/*
* 문제 Q049 : 난수 생성하기 (srand, rand)
* 학습 내용 : 임의의 수, 난수를 구하는 방법을 이해합니다.
* 힌트 내용 : srand() 와 rand() 함수를 사용합니다.
*/
#include <iostream>
// 0. ctime 라이브러리
#include <ctime>
using namespace std;
int main() {
// 1. srand() : 난수 초기화; seed == 시간
srand(static_cast<unsigned int>(time(NULL)));
// 2. rand() : 무작위 값 생성; by seed
for (int i = 0; i < 5; i++)
cout << i+1 << "번째 난수 : " << rand() << endl;
return 0;
}
/*
1. srand() 와 rand()
난수를 구할 땐 해당 정보를 프로그램 안에서 한 번은 초기화해야 합니다.
이때 난수를 구하기 위해선 seed 값이 필요한데 보통은 시스템 시간을 사용합니다.
seed 를 기준으로 무작위 값이 생성되므로 seed 값은 계속 바뀌어야 합니다.
seed 가 변하지 않는 값이면 매 실행마다 같은 결과가 출력됩니다.
srand (seed) : 난수의 seed 를 심는 과정.
rand() : srand(seed) 에서의 seed 값을 이용해 무작위 값을 반환한다.
*/
/*
* 출력 결과
1번째 난수 : 2729
2번째 난수 : 26341
3번째 난수 : 3114
4번째 난수 : 16095
5번째 난수 : 3557
*/📌 [7] 날짜/시간 처리 함수
Q051. localtime_s()
/*
* 문제 Q051 : 날짜와 시간을 문자열로 변환하기 (localtime)
* 학습 내용 : 날짜를 원하는 형태로 가공하는 법을 이해합니다.
* 힌트 내용 : strftime 함수를 사용합니다.
*/
#include <iostream>
// 1. ctime 라이브러리 호출
#include <ctime>
using namespace std;
int main() {
// 2. time_t 변수; 현재 시간 구하기
time_t currentTime = time(NULL);
// 3. 로컬 시간 구조체 선언
struct tm localTime;
// 4. localtime_s() 함수; 현재 시간을 로컬 시간 구조체에 저장
localtime_s(&localTime, ¤tTime);
// 4. strftime(array[], size, %Y %m %d %H %M %S %p) : 날짜, 시간을 원하는 형식의 문자열로 변경하여, 배열(1)에 (2)크기만큼 문자열(3)을 할당하는 함수
char buffer[64];
strftime(buffer, sizeof(buffer), "오늘은 %Y년 %m월 %d일, %H시 %M분 %S초 입니다. (%p) \n", &localTime);
cout << buffer;
return 0;
}
/*
1. tm 구조체
#include <ctime>
struct tm {
int tm_sec; // 초
int tm_min; // 분
int tm_hour; // 시
int tm_mday; // 일
int tm_mon; // 월
int tm_year; // 년
int tm_wday; // 요일
int tm_yday; // 1월 1일 부터 몇 일이 지났는지 [0, 6]
int tm_isdst; // 서머 타임제 실시 여부
};
*/
/*
* 출력 결과
오늘은 2023년 07월 07일, 07시 07분 07초 입니다. (PM)
*/Q051. time(), difftime()
/*
* 문제 Q052 : 지나간 시간 알아내기 (time, difftime)
* 학습 내용 : 특정 시간에서 몇 초가 지났는지 알아내는 방법을 이해합니다.
* 힌트 내용 : difftime( ) 함수를 사용합니다.
*/
#include <iostream>
#include <ctime>
using namespace std;
int main() {
time_t startTime = time(NULL);
time_t finishTime = time(NULL);
int num = 0;
time(&startTime);
for (int i = 1; i < 1000; i++) {
for (int j = 1; j < 1000; j++) {
for (int k = 1; k < 1000; k++)
num += 1;
}
}
time(&finishTime);
cout << "1을 1000,000,000번 더하는 데 걸린 시간 : " << difftime(finishTime, startTime) << "초" << endl;
return 0;
}
/*
1. 현재 시간 저장
time_t xTime = time(NULL);
time(&xTime);
2. 시간 차이 반환 함수 [초]
difftime(finishTime, startTime)
*/
/*
* 출력 결과
1을 1000,000,000번 더하는 데 걸린 시간 : 2초
*/📌 [8] 문자열 처리 함수
Q053. STR1.compare(STR2)
/*
* 문제 Q053 : 문자열 비교하기 (string.compare)
* 학습 내용 : string 문자열 변수를 비교하는 방법을 이해합니다.
* 힌트 내용 : string.compare( ) 함수를 사용합니다.
*/
#include <iostream>
using namespace std;
int main() {
string hiphop1 = "beenzino";
string hiphop2 = "blacknut";
// STR1.compare(STR2); 같으면 0/ 다르면 -1 반환 함수
if (hiphop1.compare(hiphop2) == 0)
cout << "두 래퍼는 동일 인물 입니다." << endl;
else
cout << "두 래퍼는 다른 인물 입니다." << endl;
return 0;
}
/*
1. STR1.compare(STR2)
같으면 0 반환
다르면 -1 반환
*/
/*
* 출력 결과
두 래퍼는 다른 인물 입니다.
*/Q054. STR.find(strX)
/*
* 문제 Q054 : 문자열 조회하기 (find)
* 학습 내용 : 문자열 안에 어떤 문자 또는 문자열이 있는지 확인하는 방법을 이해합니다.
* 힌트 내용 : string.find( ) 함수를 사용합니다.
*/
#include <iostream>
#include <string>
using namespace std;
int main() {
string strWave = "You can't stop the waves, but you can learn to surf";
// 반환 변수 선언
int rtn = strWave.find("wave");
if (rtn != -1)
cout << "wave 찾음! 위치 : " << rtn << endl;
else if (rtn == -1)
cout << "wave 찾지 못했음" << endl;
return 0;
}
/*
1. STRfind.find(STR)
반환하는 수는 w*ave에서 별의 위치
*/
/*
* 출력 결과
wave 찾음! 위치 : 19
*/Q055. STR.length()
/*
* 문제 Q055 : 문자열 길이 구하기 (length)
* 학습 내용 : 문자열의 전체 길이를 구하는 방법을 이해합니다.
* 힌트 내용 : string.find( ) 함수를 사용합니다.
*/
#include <iostream>
#include <string>
using namespace std;
int main() {
string strWave = "You can't stop the waves, but you can learn to surf";
cout << "strWave 의 길이 : " << strWave.length() << endl;
return 0;
}
/*
1. STR.length() 한/영 길이
한글 : 한 글자 2 [Byte]
영어 : 한 글자 1 [Byte]
그래서 한글은 영문에 비해 문자열 길이가 2배로 늘어난다.
*/
/*
* 출력 결과
strWave 의 길이 : 51
*/Q056. toupper(STR), tolower(STR)
/*
* 문제 Q056 : 문자열 대소문자 변환하기 (toupper, tolower)
* 학습 내용 : 하나의 문자나 문자열 전체를 대소문자로 변환하는 방법을 이해합니다.
* 힌트 내용 : 문자를 변환하는 함수와 문자열을 변환하는 함수는 다릅니다.
*/
#include <iostream>
#include <string>
#include <algorithm>
using namespace std;
int main() {
char chWave = 'w';
string strWave = "You can't stop the waves, but you can learn to surf";
// 1. 문자 대,소문자 변환
chWave = toupper(chWave);
cout << chWave << endl;
chWave = tolower(chWave);
cout << chWave << endl;
// 2. 문자열 대,소문자 변환
transform(strWave.begin(), strWave.end(), strWave.begin(), toupper);
cout << strWave << endl;
transform(strWave.begin(), strWave.end(), strWave.begin(), tolower);
cout << strWave << endl;
return 0;
}
/*
1. transform (1, 2, 3, 4) 함수 인자 전달 순서
1. 복사할 문자열의 시작점
2. 복사할 문자열의 종료점
3. 붙여넣기할 문자열의 시작점 (다른 문자열 변수에 대입 가능)
4. toupper/ tolower
*/
/*
* 출력 결과
W
w
YOU CAN'T STOP THE WAVES, BUT YOU CAN LEARN TO SURF
you can't stop the waves, but you can learn to surf
*/Q057. STR1 += strX
/*
* 문제 Q057 : 문자열 합치기 (+=)
* 학습 내용 : 특정 문자열에 다른 문자열을 추가하는 방법을 이해합니다.
* 힌트 내용 : 간단하게 + 연산자를 이용합니다.
*/
#include <iostream>
using namespace std;
int main() {
// "You are _____ than you believe, _____ than you seem, and _____ than you think."
string str1 = "braver ";
string str2 = "stronger ";
string str3 = "smarter ";
string pooh = "";
// 1. +=
pooh += "You are ";
pooh += str1;
pooh += "than you believe, ";
cout << pooh << endl;
// 2. STR.append(STR1)
pooh.append(str2);
pooh.append("than you seem, ");
cout << pooh << endl;
// 3. +
pooh = pooh + "and " + str2 + "than you think.";
cout << pooh << endl;
return 0;
}
/*
1. += 과 append
둘다 동일한 기능을 한다.
2. string + 연산자
string + 연산자를 이용하면 string, char, const char * 도 쉽게 추가할 수 있습니다.
string 은 내부 버퍼를 가지고 있으므로 가변 길이 문자열 처리가 가능합니다.
또한 append, insert, push_back 함수로도 문자 또는 문자열을 추가할 수 있습니다.
string.append("ABC", 2) 처럼 추가할 문자열의 크기를 지정할 수 있으며,
string.append("ABC", 1, 2) 처럼 문자열 일부만 추출해 추가할 수도 있습니다.
insert 를 응용할 경우,
string.insert(2, "ABC", 2), string.insert(0, "ABC", 1, 2) 처럼
추가할 영역, 추가할 문자열 범위 등을 설정할 수도 있습니다.
*/
/*
* 출력 결과
You are braver than you believe,
You are braver than you believe, stronger than you seem,
You are braver than you believe, stronger than you seem, and stronger than you think.
*/Q058. STR.insert(n, strX)
/*
* 문제 Q058 : 문자열 중간에 문자열 추가하기 (insert)
* 학습 내용 : 문자열 중간에 다른 문자열을 추가하는 방법을 이해합니다.
* 힌트 내용 : insert 함수를 이용합니다.
*/
#include <iostream>
#include <string>
using namespace std;
int main() {
// 0Y1o2u3 4a5r6e7 8t9h10a11n12 13you think.
string pooh = "You are than you think.";
pooh.insert(8, "braver ");
cout << pooh << endl;
return 0;
}
/*
1. insert()
include <string>
STR.insert(위치n, STR2);
*/
/*
* 출력 결과
You are braver than you think.
*/Q059. STR.erase(n, m)
/*
* 문제 Q059 : 문자열 일부 지우기 (erase)
* 학습 내용 : 문자열의 일부를 제거하는 방법을 이해합니다.
* 힌트 내용 : erase 함수를 이용합니다.
*/
#include <iostream>
#include <string>
using namespace std;
int main() {
string pooh = "You are braver than you think.";
pooh.erase(13, 16);
cout << pooh << endl;
return 0;
}
/*
1. erase()
#include <string>
STR.erase(위치n, 제거할 문자 수n);
*/
/*
* 출력 결과
You are brave.
*/Q060. move(STR)
/*
* 문제 Q060 : 문자열 잘라 붙여넣기 (move)
* 학습 내용 : 문자열을 다른 변수로 이동(잘라 붙여넣기)하는 방법을 이해합니다.
* 힌트 내용 : move() 함수를 이용합니다.
*/
#include <iostream>
using namespace std;
int main() {
string pooh = "You are braver than you think.";
string blank = " it's nothing ";
blank = move(pooh);
cout << "pooh : " << pooh << endl;
cout << "blank: " << blank << endl;
return 0;
}
/*
1. move()
STR_new = move(STR_old);
old -> new 잘라 붙여넣기
*/
/*
* 출력 결과
pooh :
blank: You are braver than you think.
*/Q061. STR.erase(), STR.remove()
/*
* 문제 Q061 : 문자열에서 특정 문자만 제거하기 (erase, remove)
* 학습 내용 : 문자열에서 임의의 문자만 제거하는 방법을 이해합니다.
* 힌트 내용 : erase 함수와 remove 함수를 함께 이용합니다.
*/
#include <iostream>
#include <string>
#include <algorithm>
using namespace std;
int main() {
string strOaz = "oabcdeABCDOabcde";
cout << " 0. " << strOaz << endl;
// 1. 문자의 위치를 이용해 지우기
// 1.1. 위치 하나
strOaz.erase(strOaz.begin() + 5);
cout << "1.1. " << strOaz << endl;
// 1.2. 위치 범위
strOaz.erase(1, 4);
cout << "1.2. " << strOaz << endl;
// 2. 특정 문자를 모두 지우기
strOaz = "oabcdeABCDOabcde";
remove(strOaz.begin(), strOaz.end(), 'b');
cout << "2.1. " << strOaz << endl;
strOaz.erase(remove(strOaz.begin(), strOaz.end(), 'c'), strOaz.end());
cout << "2.2. " << strOaz << endl;
return 0;
}
/*
1. v.erase() 함수
1.1. v.erase(삭제하려는 값의 위치 Index);
1.2. v.erase(iFirst, iLast);
범위를 지정하여 컨테이너에서 원소를 삭제하는 함수입니다.
2. remove() 함수
remove(iFirst, iLast, 'C');
원소들을 숨기고 컨테이너의 끝으로 이동시키는 함수입니다.
주어진 값과 일치하는 원소를 찾아 해당 원소를 숨기고, 나머지 원소들을 앞으로 이동시킵니다.
삭제되지 않은 가장 마지막 값 다음 위치의 iterator를 반환합니다.
v = "01234512340"
remove(v.begin(), v.end(), '3'); // v == "01245124040", return 9
a) 특정 문자('3')들을 숨기고 문자열 맨 뒤로 보낸다.
v = "01245124040"
* 맨 뒤로 숨길때, 문자열의 마지막 값들로 변환하여 숨긴다.
* 이렇게, 문자열의 길이는 그대로 유지된다.
b) 이후, 원래 문자열의 마지막 인덱스의 다음값을 반환한다. (즉, 숨겨져 옮겨진 값들의 첫 인덱스)
index = 9 반환
3. v.erase( remove(v.begin(), v.end(), '3'), v.end());
3.1. remove 함수가 적용된 v
v = "01245124040"
3.2. remove 함수의 반환값
remove() 로부터 index = 9 반환
3.3. 반환받은 v.erase() 함수
v.erase( 9, v.end());
3.4. 결과
v = "012451240" // 맨뒤의 "40" (index = 9, 10) 지워짐
*/
/*
* 출력 결과
0. oabcdeABCDOabcde
1.1. oabcdABCDOabcde
1.2. oABCDOabcde
2.1. oacdeABCDOacdede
2.2. oadeABCDOadede
*/Q062. STR.replace()
/*
* 문제 Q062 : 문자열 일부 교체하기 (replace)
* 학습 내용 : 문자열의 일부를 교체하는 방법을 이해합니다.
* 힌트 내용 : STR.replace() 함수과 STR.find() 함수를 이용합니다.
*/
#include <iostream>
#include <string>
using namespace std;
int main() {
string wave = "You can't SHOP the waves, but you can learn to surf";
string findStr = "SHOP";
string replaceStr = "STOP";
wave.replace(wave.find(findStr), findStr.length(), replaceStr);
cout << wave << endl;
return 0;
}
/*
1. STR.replace(pos, count, str);
1.1. pos (Position)
대체를 시작할 위치를 나타내는 인자입니다.
대체 작업은 pos 위치에서부터 시작됩니다.
일반적으로 이 값은 문자열 내에서 찾으려는 대체 대상의 시작 위치를 가리킵니다.
1.2. count (Count)
대체할 부분의 길이를 나타내는 인자입니다.
count 값은 대체 대상의 길이를 가리킵니다.
대체 작업은 pos 위치로부터 count만큼의 길이를 대체 문자열로 대체합니다.
1.3. str (String)
대체할 새로운 문자열을 나타내는 인자입니다.
str은 대체 대상을 대체할 새로운 문자열로 대체됩니다.
2. STR.find(STRfind)
전체 문자열 STR 에서 "STRfind" 를 찾아 위치의 index 를 반환한다.
3. STR.length()
문자열 STR 의 길이를 반환한다.
*/
/*
* 출력 결과
You can't STOP the waves, but you can learn to surf
*/Q063. stoi(STR)
/*
* 문제 Q063 : 문자열을 정수로 변환하기 (stoi)
* 학습 내용 : 문자열을 int 정수로 변환하는 방법을 이해합니다.
* 힌트 내용 : C++ 11 이상에서 지원하는 stoi() 또는 atoi() 함수를 이용합니다.
*/
#include <iostream>
#include <string>
using namespace std;
int main() {
string str1 = "37";
string str2 = "3.14"; // 실수
string str3 = "123 and this is not number"; // 문자열이 같이 있는 경우
int num1 = stoi(str1);
int num2 = stoi(str2);
int num3 = stoi(str3);
cout << "num1 : " << num1 << endl; // 37
cout << "num2 : " << num2 << endl; // 3
cout << "num3 : " << num3 << endl; // 123
return 0;
}
/*
1. stoi(STR)
1.1. 정수로만 변환한다.
소수점 이하는 버려진다.
1.2. 숫자만 남긴다.
문자열은 버려진다.
2. atoi()
C 언어 스타일의 정수 변환 함수.
VS 가 C++ 11 문법을 사용할 수 있는 VS2012 버전보다 낮다면 사용.
*/
/*
* 출력 결과
num1 : 37
num2 : 3
num3 : 123
*/Q064. stringstream
/*
* 문제 Q064 : 문자열을 숫자로 변환하기 (stringstream)
* 학습 내용 : stringstream 을 이용해 문자열을 정수, 실수로 변경하는 방법을 이해합니다.
* 힌트 내용 : stoi 와 결과는 똑같지만 방법은 다릅니다.
*/
#include <iostream>
// 0. <sstream> include for stringstream
#include <sstream>
using namespace std;
int main() {
// 1. stringstream 변수 선언
stringstream ss;
double number1 = 0.0;
// 2. ss 변수에 실수+특수문자 섞인 문자열 대입
ss << "3.1,3.7-1.616!3.3=11.1";
cout << "[string to double]" << endl;
// 3. !ss.eof : ss 를 다 읽을 때까지 반복
while (!ss.eof()) {
// 3.1. 실수 변수에 ss 내의 실수 대입
ss >> number1;
// 3.2. ss.ignore : 처음으로 돌아가지 않고 다음 데이터를 읽을 수 있도록 한다. (무한루프 방지)
ss.ignore();
cout << number1 << ", ";
}
// 4. ss.clear : ss 파일을 끝까지 읽어서 더는 읽을 수 없는 상태를 초기화
ss.clear();
// 5. ss.str : ss 변수의 데이터 초기화
ss.str("");
// +. 문자열 -> 정수 변환
// 1. ss 에 문자열 대입하는 두 번째 방식
ss << "1, " << "2" << 3 << "@" << 7;
int number2 = 0;
cout << "\n[string to int]" << endl;
while (!ss.eof()) {
ss >> number2;
ss.ignore();
cout << number2 << ", ";
}
return 0;
}
/*
1. stringstream
#include <sstream>
stringstream ss;
ss << "strNum";
while(!ss.eof()){
ss >> numbX;
ss.ignore();
}
ss.clear();
ss.str("");
* 문자열내의 특수 문자는 두개이상 연속되면 안된다.
*/
/*
* 출력 결과
[string to double]
3.1, 3.7, 1.616, 3.3, 11.1,
[string to int]
1, 23, 7,
*/Q065. sort()
/*
* 문제 Q065 : 문자열 정렬하기 (sort)
* 학습 내용 : 문자열을 구성하는 알파벳들을 순서대로 정렬하는 방법을 이해합니다.
* 힌트 내용 : sort() 함수를 이용하면 쉽게 정렬할 수 있습니다.
*/
#include <iostream>
#include <string>
#include <algorithm>
using namespace std;
int main() {
string strOaz = "oAbCdEaBcDO";
cout << strOaz << endl;
sort(strOaz.begin(), strOaz.end());
cout << strOaz << endl;
return 0;
}
/*
* 출력 결과
oAbCdEaBcDO
ABCDEOabcdo
*/Q066. reverse()
/*
* 문제 Q066 : 문자열 뒤집기 (reverse)
* 학습 내용 : 문자열을 뒤에서 앞으로 순서를 바꿔 뒤집는 방법을 이해합니다.
* 힌트 내용 : reverse() 함수를 이용합니다.
*/
#include <iostream>
#include <string>
#include <algorithm>
using namespace std;
int main() {
string myStr = "Stressed";
cout << myStr << endl;
reverse(myStr.begin(), myStr.end());
cout << myStr << endl;
return 0;
}
/*
* 출력 결과
Stressed
dessertS
*/Q067. to_string()
/*
* 문제 Q067 : 숫자를 문자열로 변환하기 (to_string)
* 학습 내용 : 정수와 실수를 문자열로 바꾸는 방법을 이해합니다.
* 힌트 내용 : to_string() 함수를 이용합니다.
*/
#include <iostream>
#include <string>
using namespace std;
int main() {
int myNumbInt = 37;
double myNumbDoub = 3.14;
string myStrInt = to_string(myNumbInt);
string myStrDoub = to_string(myNumbDoub);
cout << myStrInt << ", " << myStrDoub << endl;
return 0;
}
/*
* 출력 결과
37, 3.140000
*/Q068. min(), max(), minmax()
/*
* 문제 Q068 : 정수와 문자의 최대/최소값 알아내기 (min, max)
* 학습 내용 : 정수나 문자의 최대, 최소값을 알아내는 방법을 이해합니다.
* 힌트 내용 : min(), max(), minmax() 함수를 이용합니다.
*/
#include <iostream>
#include <string>
#include <algorithm>
using namespace std;
int main() {
auto atMin = min(7, 3);
auto atMax = max('A', 'Z');
cout << atMin << endl;
cout << atMax << endl;
auto atMinMax1 = minmax({ 11, 3, 777 });
auto atMinMax2 = minmax({ 'a', 's', 'z' });
cout << atMinMax1.first << ", " << atMinMax1.second << endl;
cout << atMinMax2.first << ", " << atMinMax2.second << endl;
return 0;
}
/*
1. auto 자료형
반환형이 무엇인지 모를 때 사용할 수 있는 유용한 키워드
*/
/*
* 출력 결과
3
Z
3, 777
a, z
*/📌 [9] pointer
Q069. *, &
/*
* 문제 Q069 : 포인터 이해하기 (*)
* 학습 내용 : 특정 대상의 주소를가리키는 포인터를 이해합니다.
* 힌트 내용 : C언어의 꽃은 배열, 함수 그리고 포인터라는 말이 있습니다.
*/
#include <iostream>
using namespace std;
int main() {
// 1. *주소를 저장하는 포인터 변수 선언과 &변수의 주소를 불러오는 앰퍼샌드
int num1 = 37;
int *pt1 = &num1;
// 2. 변수와 *변수의 사이즈
cout << num1 << "; Size == " << sizeof(num1) << " [Byte]" << endl;
cout << pt1 << "; Size == " << sizeof(pt1) << " [Byte]" << endl;
return 0;
}
/*
1. 포인터 변수와 &(앰퍼샌드)
*pt = &var
*pt : 주소를 담는 변수
& : 변수의 주소 호출
2. 포인터 변수의 사이즈
컴파일러 설정에 따라 바뀐다.
x32로 컴파일 : 4 Byte
x64로 컴파일 : 8 Byte
*/
/*
* 출력 결과
37; Size == 4 [Byte]
00000004044FF784; Size == 8 [Byte]
*/Q070. func(*)
/*
* 문제 Q070 : 포인터 변수 사용하기
* 학습 내용 : 함수를 이용하여 포인터 변수를 사용하는 방법을 이해합니다.
* 힌트 내용 : 포인터는 프로그램 성능을 향상하는데 도움이 됩니다.
*/
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int ptFunc(vector<string> *strX) {
if (strX->empty() == true)
return 0;
else
return sizeof(strX);
}
int main() {
vector<string> strWave;
strWave.push_back("you can't stop the waves, ");
strWave.push_back("but you can learn to surf.");
cout << "문자열의 크기 : " << sizeof(strWave) << endl;
cout << "문자열의 포인터 크기 : " << ptFunc(&strWave) << endl;
return 0;
}
/*
1. 포인터를 인자로 받는 함수
1.1. 함수 선언 및 내용
func(*x)
{
x
}
1.2. 함수 호출
func(&x)
즉, 함수는 사실 변수의 주소를 받는 것이다.
2. 함수에서 포인터 사용의 성능 향상
함수는 인자로 넘어오는 값을 복사해서 사용한다.
이때, 인자의 크기가 크다면 복사하는데 많은 시간이 소요된다.
포인터는 주소값(8 바이트)이라서, 변수를 사용할 때, 주소만 불러와서 사용한다면
인자 복사 시간이 감소함에 따라, 프로그램 성능 향상에 도움이 된다.
/*
/*
* 출력 결과
문자열의 크기 : 32
문자열의 포인터 크기 : 8
*/Q071. *pt + n
/*
* 문제 Q071 : 포인터 배열 사용하기
* 학습 내용 : 배열을 가리키는 포인터 사용 방법을 이해합니다.
* 힌트 내용 : 해당 포인터는 배열 인덱스 0을 가리킵니다.
*/
#include <iostream>
using namespace std;
int main() {
const int kSize = 3;
cout << "[ int* pt1 = Array; ]" << endl << endl;
int numArr[kSize] = { 10, 20, 30 };
int* pt1 = numArr;
int no1 = 1;
cout << "arr[0] == " << numArr[0] << endl;
cout << "arr == " << numArr << endl;
cout << "pt1 == " << pt1 << endl;
cout << "*pt1 == " << *pt1 << endl << endl;
for (int i = 0; i < kSize; i++)
cout << "*(pt1 + " << i << ") == " << *(pt1 + i) << endl;
cout << "\n\n[ int* pt2[3] = { &z, &y, &z }; ]" << endl << endl;
int num1 = 111;
int num2 = 222;
int num3 = 333;
int* pt2[kSize] = { &num1, &num2, &num3 };
cout << " pt2 == " << pt2 << endl;
cout << " *pt2 == " << *pt2 << endl;
cout << "pt2[0] == " << pt2[0] << endl;
cout << " &x == " << &num1 << endl << endl;
for (int i = 0; i < kSize; i++)
cout << "*pt2[" << i << "] == " << *pt2[i] << " == num" << i << endl;
return 0;
}
/*
1. 배열 자체는 주소를 담는다. (&arr 가 아니다.)
int arr[3] = { 1, 2, 3 };
int* pt = arr;
1.1. pt
arr의 주소(pt)를 담고 있다.
1.2. *pt
arr의 주소(pt)를 참조(*)하여 배열의 내용, 그 첫번째 *pt == arr[0] 를 반환한다.
1.3. *(pt+2)
주소의 시작점(pt)에서 int 만큼 두번 건너뛴 메모리 주소(pt+2)를 참조(*)하여, arr[2] 반환
;arr의 2번째 내용의 주소(pt+2)를 참조(*)하여 arr[2]를 반환한다.
2. 포인터 배열 : 내용이 &주소인 배열
int* pt[3] = { &x, &y, &z };
1.1. pt
포인터 배열{&}의 주소(pt)
1.2. *pt
포인터 배열{&}의 주소(pt)를 참조(*), 그 첫번째 내용(&x)
1.3. pt[0]
배열[n] 형식은 더이상 주소가 아닌, 내용 자체다. 그러므로 포인터 배열{&}의 첫번째 내용(&x)
1.4. *pt[0]
포인터 배열{&}의 첫 내용(&x)를 참조(*), *(&x) == x
*(pt[n]) == *(&x) == x
3. dereference(참조 해제)
: 포인터를 사용하여 메모리 주소에 저장된 값을 가져오는 작업
포인터는 변수의 메모리 주소를 담고 있으며,
포인터를 dereference 하면,
해당 메모리 주소에 저장된 값을 얻을 수 있다.
메모리 주소 앞에 * 연산자를 사용하면,
주소가 가리키는 메모리 주소에 저장된 내용을 가져온다.
pt : pt 가 가리키는(담고있는) 주소 출력
*pt : 주소에 저장된 데이터, 값 출력
*/
/*
* 출력 결과
[ int* pt1 = Array; ]
arr[0] == 10
arr == 0000007C92B8FB08
pt1 == 0000007C92B8FB08
*pt1 == 10
*(pt1 + 0) == 10
*(pt1 + 1) == 20
*(pt1 + 2) == 30
[ int* pt2[3] = { &z, &y, &z }; ]
pt2 == 0000007C92B8FBF8
*pt2 == 0000007C92B8FB94
pt2[0] == 0000007C92B8FB94
&x == 0000007C92B8FB94
*pt2[0] == 111
*pt2[1] == 222
*pt2[2] == 333
*/📌 [10] 변수의 유효 범위
Q072. 지역 변수
/*
* 문제 Q072 : 지역 변수 이해하기
* 학습 내용 : 지역 변수를 사용하는 방법을 이해합니다.
* 힌트 내용 : 변수는 유효 범위에 따라 부르는 이름이 다릅니다.
*/
#include <iostream>
using namespace std;
int func1(const int x) {
int just_number = 333;
return just_number;
}
int func2(const int x) {
return x;
}
int main() {
int x = 7;
int y1 = func1(x);
int y2 = func2(x);
cout << "x of main() == " << x << endl;
cout << "y1 of func1() == " << y1 << endl;
cout << "y2 of func2() == " << y2 << endl;
}
/*
1. 지역 변수 : 변수의 유효범위
일반적으로 같은 이름의 변수나 함수는 사용할 수 없으나,
유효 범위가 다르다면 같은 이름의 변수를 선언하여 사용할 수 있습니다.
*/
/*
* 출력 결과
x of main() == 7
y1 of func1() == 333
y2 of func2() == 7
*/Q073. 전역 변수
/*
* 문제 Q073 : 전역 변수 이해하기 (extern)
* 학습 내용 : 유효 범위가 넓은 전역 변수 사용 방법을 이해합니다.
* 힌트 내용 : 프로그램 어느 곳에서나 접근하여 사용할 수 있는 것들을 전역이라 부릅니다.
*/
#include <iostream>
using namespace std;
extern int globalNumber = 777;
int func1() {
return globalNumber++;
}
int func2() {
return globalNumber++;
}
int main() {
int locNumber = globalNumber++;
cout << "@main() == " << locNumber << endl;
cout << "@func1() == " << func1() << endl;
cout << "@func2() == " << func2() << endl;
cout << "@main() == " << locNumber << endl;
cout << "@func1() == " << func1() << endl;
cout << "@func2() == " << func2() << endl;
return 0;
}
/*
1. 전역 변수
프로그램 어느 곳에서나 접근할 수 있는 변수
즉, 함수내에서 변수 내용을 변경할 수 있다.
2. 객체지향 언어에서의 전역 변수
C++ 같은 객체지향 프로그래밍 언어엔 전역이란 개념 자체가 없다.
"쓰면 안된다!"
억지로 전역 변수, 전역 함수를 사용하면
- 네임스페이스 오염
- 커플링 문제
- 메모리 할당
- 테스트 어려움 등의 많은 부작용들이 생긴다.
*/
/*
* 출력 결과
@main() == 777
@func1() == 778
@func2() == 779
@main() == 777
@func1() == 780
@func2() == 781
*/📌 [11] Call by
Q074. func(x)
/*
* 문제 Q074 : Call by Value 이해하기
* 학습 내용 : 함수는 인자를 받을 때 복사해서 사용한다는 개념을 이해합니다.
* 힌트 내용 : 인자 값을 직접 복사해서 사용하는 것이 Call by Value 입니다.
*/
#include <iostream>
using namespace std;
void func(int x) {
cout << "Before : " << x << endl;
x *= 100;
cout << "After : " << x << endl;
}
int main() {
int num = 3;
func(num);
cout << "func end : " << num << endl;
return 0;
}
/*
1. Call by Value
함수는 인자 값을 '복사'해서 사용한다.
그러므로 본래의 값은 변하지 않는다.
*/
/*
* 출력 결과
Before : 3
After : 300
func end : 3
*/Q075. func(& x)
/*
* 문제 Q075 : Call by Reference 이해하기
* 학습 내용 : 함수가 변수의 주소(참조)를 받아 사용한다는 개념을 이해합니다.
* 힌트 내용 : 변수의 주소(참조)를 이용하는 것이 Call by Reference 입니다.
*/
#include <iostream>
using namespace std;
// 1. 함수 인자로 변수의 참조(레퍼런스)를 전달 받는다.
void func_and(int &x) {
cout << "Before x : " << x << endl;
x *= 100;
cout << "After x : " << x << endl;
}
void func_pt(int* y) {
cout << "Before y : " << *y << endl;
*y *= 111;
cout << "After y : " << *y << endl;
}
int main() {
int numX = 3;
int numY = 7;
func_and(numX);
cout << "func& end : " << numX << endl << endl;
func_pt(&numY);
cout << "func* end : " << numY << endl;
return 0;
}
/*
1. 주소를 사용하는 함수
1.1. Call by Reference
func(&x){ // 매개변수를 참조 형태로 선언
x
}
func(xxx)
1.2. Call by Address
func(* x){
*x
}
func(&xxx)
// 포인터 변수 x <- 주소(&xxx)를 담는다. 사용할땐 참조(*)해서 사용해야 한다.
2. func_and
func_and 함수를 호출하고 정수 변수를 인자로 전달하면, 해당 변수의 메모리 주소가 함수로 전달됩니다.
함수 내부에서 매개변수 x는 원본 변수에 대한 참조이며, 독립적인 복사본이 아닙니다. 함수 내에서 x를 수정하면 전달된 원본 변수에도 직접 영향을 미칩니다.
함수는 참조 x를 사용하여 원본 변수의 값을 읽거나 수정할 수 있습니다. 주어진 함수에서는 x의 값을 100배로 곱하고 수정합니다.
*/
/*
* 출력 결과
Before : 3
After : 300
func& end : 300
Before y : 7
After y : 777
func* end : 777
*/Q076. func(* ptX)
/*
* 문제 Q076 : Call by Address 이해하기
* 학습 내용 : Call by Reference 와의 차이점을 알아보고 사용 방법을 이해합니다.
* 힌트 내용 : 주소를 명시적으로 전달받아 8바이트가 할당됩니다.
*/
#include <iostream>
using namespace std;
// 1. Call by Value( x)
// x 를 복사하여 '복사된' x 를 다룸
void funcCbValu(bool isOn) {
cout << "size : " << isOn << endl;
cout << "Call by Value : " << sizeof(isOn) << endl << endl;
}
// 2. Call by Reference(& x)
// x 의 주소를 참조하여 x 를 '직접' 다룸
void funcCbRefr(bool& isOn) {
cout << "size : " << isOn << endl;
cout << "Call by Reference : " << sizeof(&isOn) << endl << endl;
}
// 3. Call by Address(* pt)
// pt 가 '가리키는' 값을 다룸
void funcCbAddr(bool* ptIsOn){
cout << "size : " << *ptIsOn << endl;
cout << "Call by Address : " << sizeof(ptIsOn) << endl << endl;
}
int main() {
bool onOff = true;
funcCbValu(onOff); // 2. x의 값을 함수에 전달 (값에 의한 호출)
funcCbRefr(onOff); // 2. x의 주소를 함수에 전달 (참조에 의한 호출)
funcCbAddr(&onOff); // 3. x의 주소를 함수에 전달 (포인터 이용한 호출)
return 0;
}
/*
1. Call by X 특징
1.1. Value
'값'에 의한 호출
* 함수 내에서 매개변수의 값을 변경해도 호출자에게 영향을 미치지 않습니다.
* 예측 가능 : 함수 호출 시 전달된 값은 변경되지 않으므로, 함수의 동작이 예측 가능합니다.
* 복사 비용 증대 : 인자가 복사되기 때문에 함수에 크기가 큰 객체를 전달하면 성능 저하가 발생할 수 있습니다.
* 수정 불가능한 매개변수: 함수 내에서 값을 변경해도 호출자에게 영향을 미치지 않기 때문에, 매개변수를 통해 수정할 수 없는 경우가 있습니다.
1.2. Reference
'참조'에 의한 호출
* 메모리 절약 : 복사 대신 변수의 참조를 전달하므로, 큰 객체를 다룰 때 메모리 절약이 가능합니다.
* 값 변경 가능 : 함수 내에서 매개변수의 값을 변경하면 호출자의 변수도 영향을 받습니다.
* 예측 어려움 : 함수 내에서 매개변수를 변경하면 호출자의 값도 변경되기 때문에, 예상치 못한 부작용이 발생할 수 있습니다.
1.3. Address
'주소(포인터)'에 의한 호출
* 메모리 절약 : 포인터(주소)를 전달하므로 복사 비용이 없어 메모리를 절약할 수 있습니다.
* 값 변경 가능: 함수 내에서 포인터를 통해 값을 변경하면 호출자의 변수도 영향을 받습니다.
* 잘못된 포인터 사용: 잘못된 포인터 조작으로 인해 프로그램이 충돌하거나 버그가 발생할 수 있습니다.
* 복잡성 : 포인터 사용은 복잡성을 증가시킬 수 있으며, 메모리 누수 등의 문제가 발생할 수 있습니다.
각 호출 방식은 상황에 맞게 적절히 선택되어야 합니다.
함수가 매개변수를 변경하지 않고 값을 계산하는 데에만 의존한다면 Call by Value가 적합합니다.
하지만 큰 객체를 다룰 때는 Call by Reference나 Call by Address가 성능상 유리할 수 있습니다.
그러나 포인터를 사용할 때는 주의해야 하며, 필요 이상으로 복잡하게 만들지 않도록 주의해야 합니다.
2. 참조와 포인터
'참조' : 변수에 별칭을 부여하는 개념입니다.(int& x)
2.1. 참조에 의한 호출
"Call by Reference"를 사용하면 함수에 실제 변수를 참조로 전달합니다.
이는 함수가 원래 변수를 직접적으로 메모리에서 다룰 수 있게 해줍니다.
변수의 복사본을 만들지 않으므로 메모리 사용이 최소화됩니다.
즉, 함수에게는 변수의 주소(참조)가 전달됩니다.
* "참조에 의한 호출"은 함수에 변수의 참조(레퍼런스)를 전달하는 방식입니다.
* 함수 선언 시, 매개변수가 참조 형태로 선언되어야 합니다. 참조는 변수에 별칭을 부여하는 개념입니다. (int& x)
* 함수 내에서 참조를 이용하여 변수를 변경하면, 호출자의 변수도 영향을 받게 됩니다.
* 이 방식은 포인터를 이용한 호출보다 더 직관적이고 간결하며, 포인터 변수의 추가적인 오버헤드가 없습니다.
2.2. 포인터를 이용한 호출
"Call by Address"를 사용하면 함수에 포인터(메모리 주소)를 전달합니다.
함수는 이 포인터를 사용하여 값을 참조해야 합니다.
값 자체는 복사되지 않지만, 포인터 변수를 추가로 사용해야 하므로 메모리 사용에 약간의 오버헤드가 있습니다.
* "포인터를 이용한 호출"은 함수에 변수의 메모리 주소(포인터)를 전달하는 방식입니다.
* 함수 선언 시, 매개변수가 포인터 형태로 선언되어야 합니다. (int* ptX)
* 함수 내에서 포인터를 역참조하여 변수의 값을 변경하면, 호출자의 변수도 영향을 받게 됩니다.
* 이 방식을 사용하면 함수에게 변수가 저장된 메모리 주소를 알려주는 것이므로, 변수의 크기에 상관없이 함수 호출의 메모리 오버헤드가 일정합니다.
요약하면, 참조에 의한 호출은 변수의 참조를 전달하는 방식이고, 포인터를 이용한 호출은 변수의 메모리 주소를 전달하는 방식입니다.
둘 다 함수에서 변수를 변경하면 호출자의 변수도 변경되고, 메모리 절약도 가능하지만,
* 참조에 의한 호출은 간결하고 직관적입니다.
* 포인터를 이용한 호출은 포인터 변수의 추가 메모리 오버헤드가 있을 수 있습니다.
*/
/*
* 출력 결과
size : 1
Call by Value : 1
size : 1
Call by Reference : 8
size : 1
Call by Address : 8
*/📌 [12] const
Q077. const
/*
* 문제 Q077 : const 변수 이해하기
* 학습 내용 : const 키워드란 어떤 의미인지 이해합니다.
* 힌트 내용 : 값을 바꿀 수 없는 변수가 있습니다.
*/
#include <iostream>
#include <string>
using namespace std;
int main() {
// 1. 문자열 상수 선언
const string kWave = "You can't stop the waves";
string uCanChange = "but you can learn to surf";
cout << kWave << ", " << uCanChange << endl;
return 0;
}
/*
1. const
const 는 상수로 불리우며, 값을 바꿔선 안 될 것을 의미 합니다.
일반적으로 변경되지 않을 변수들을 const 로 선언해 따로 관리하는데, 이럴 경우 매번하는 변수 선언을 생략할 수 있어서 효율적입니다.
const 는 함수 인자, 변수, 포인터 등에도 사용할 수 있어, 그 쓰임새가 다양합니다.
* 만약 상수형 변수를 바꾸려 하면 에러가 발생합니다.
* 값을 절대로 바꿀 수 없는 키워드는 const, #define, enum 이 있는데, 상황에 따라 효율적인 키워드가 다르다.
*/
/*
* 출력 결과
You can't stop the waves, but you can learn to surf
*/
📌 [13]
Q0.
Cool Kid Never Die