[열혈C++]Chapter 01 - C언어 기반의 C++ 1

목차

1. printf와 scanf를 대신하는 입출력 방식
2. 함수 오버로딩(Function Overloading)
3. 매개변수의 디폴트 값(Default Value)
4. 인라인(inline) 함수
5. 이름 공간(namespace)에 대한 소개

---

 

1. printf와 scanf를 대신하는 입출력 방식

[c++ 버전의 Hello World 출력 프로그램]

※ 헤더 파일의 선언: #include <iostream>

※ 출력의 기본 구성: std::cout<<'출력 대상 1'<<'출력 대상 2'<<'출력 대상 3';

※ 개행: std::endl

 

→ C언어에서는 출력의 대상에 따라 서식 지정이 달리했지만, C++에서는 그러한 과정이 불필요.

 

[scanf를 대신하는 데이터 입력]

※ 입력의 기본 구성: std::cin>>'변수'

→ 함수의 중간 부분에서도 변수의 선언이 가능하다.

#include <iostream>

int main(void) {
    int val1;
    std::cout<<"첫번째 숫자입력: ";
    std::cin>>val1;

    int val2;
    std::cout<<"두번째 숫자입력: ";
    std::cin>>val2;

    int result=val1+val2;
    std::cout<<"덧셈결과: "<<result<<std::endl;
    return 0;
}

 

 

[C++의 지역변수 선언]

#include <iostream>

int main(void) {
    int val1, val2;
    int result = 0;
    std::cout<<"두 개의 숫자입력: ";
    std::cin>>val1>>val2;

    if(val1<val2){
        for(int i=val1+1; i<val2; i++)
            result+=i;
    }
    else{
        for(int i=val2+1; i<val1; i++)
            result+=i;
    }
    std::cout<<"두 수 사이의 정수 합: "<<result<<std::endl;
    return 0;
}

 

두 개의 숫자입력: 3 7
두 수 사이의 정수 합: 15

 

• for문 안에서도 변수의 선언이 가능하다.
• std::cin을 통해서 입력되는 데이터의 구분은 스페이스 바, 엔터, 탭과 같은 공백을 통해서 이뤄진다.

 

[배열 기반의 문자열 입출력]

#include <iostream>

int main(void) {
    char name[100];
    char lang[200];

    std::cout<<"이름은 무엇입니까? ";
    std::cin>>name;

    std::cout<<"종아하는 프로그래밍 언어는 무엇인가요? ";
    std::cin>>lang;

    std::cout<<"내 이름은 "<<name<<"입니다. \n";
    std::cout<<"제일 좋아하는 언어는 "<<lang<<"입니다."<<std::endl;
    return 0;
}

 

이름은 무엇입니까? 유빈
좋아하는 프로그래밍 언어는 무엇인가요? C++
내 이름은 유빈입니다.
제일 좋아하는 언어는 C++입니다.

 

 

---

2. 함수 오버로딩(Function Overloading)

[함수 오버로딩의 이해]

▶ C++은 함수 호출 시 '함수의 이름'과 '전달되는 인자의 정보'를 동시에 참조하여 호출할 함수를 결정

매개변수의 선언이 다르다면 동일한 이름의 함수도 정의 가능하다.

이러한 형태의 함수 정의 → 함수 오버로딩(Function Overloading)

#include <iostream>

int MyFunc(int num){
    num++;
    return num;
}

int MyFunc(int a, int b){
    return a+b;
}

int main(void) {
    MyFunc(20); //MyFunc(int num) 함수의 호출
    MyFunc(30, 40); //MyFunc(int a, int b) 함수의 호출
    return 0;
}

 

[함수 오버 로딩의 예]

int MyFunc(char c){...}
int MyFunc(int n){...}

 

→ 매개변수의 자료형이 다르므로 함수 오버로딩 성립

int MyFunc(int n){...}
int MyFunc(int n1, int n2){...}

 

→ 매개변수의 수가 다르므로 함수 오버로딩 성립

void MyFunc(int n){...}
int MyFunc(int n){...}

 

→ 반환형의 차이는 함수 오버 로딩의 조건을 성립 X

---

3. 매개변수의 디폴트 값

[매개변수에 설정하는 '디폴트 값'의 의미]

int MyFunc(int num=7){
    return num+1;
}

 

→ 인자를 전달하지 않으면 7이 전달된 것으로 간주한다.

여기서의 디폴트 값은 7, 따라서 MyFunc();와 MyFunc(7)의 결과는 같다.

int MyFunc(int num1=5, int num2=7){
    return num1+num2;
}

 

→ 인자를 전달하지 않으면 각각 5와 7이 전달된 것으로 간주한다.

따라서 MyFunc();와 MyFunc(5,7)의 결과는 같다.

 

[디폴트 값은 함수의 선언에만 위치]

#include <iostream>

int Adder(int num1=1, int num2=2);

int main(void) {
    std::cout<<Adder()<<std::endl;
    std::cout<<Adder(5)<<std::endl;
    std::cout<<Adder(3, 5)<<std::endl;
    return 0;
}

int Adder(int num1, int num2){
    return num1+num2;
}

 

3
7
8

 

※ 함수의 선언을 별로도 둘 때에는 디폴트 값의 선언을 함수의 선언부에 위치시켜야 한다.

컴파일러는 함수의 디폴트 값의 지정 여부를 알아야 함수의 호출 문장을 적절히 컴파일할 수 있다.

 

[부분적 디폴트 값 설정]

int YourFunc(int num1, int num2=5, int num3=7){...}
    YourFunc(10); //YourFunc(10, 5, 7);
    YourFunc(10, 20); //YourFunc(10, 10, 7);

 

→ 매개변수의 일부에만 디폴트 값을 지정하고, 채워지지 않은 매개변수에만 인자를 전달하는 것이 가능하다.

 

int YourFunc(int num1, int num2, int num3=30) {...}       (o)
int YourFunc(int num1, int num2=20, int num3=30) {...}    (o)
int YourFunc(int num1=10, int num2=20, int num3=30) {...} (o)

 

→ 전달되는 인자가 왼쪽에서부터 채워지므로, 디폴트 값은 오른쪽에서부터 채워져야 한다.

 

int WrongFunc(int num1=10, int num2, int num3) {...}    (x)
int WrongFunc(int num1=10, int num2=20, int num3) {...} (x)

 

→ 전달되는 인자가 왼쪽에서부터 채워지므로, 오른쪽이 빈 상태로 왼쪽의 매개변수에만 일부 채워진 디폴트 값은 의미를 갖지 못한다. 따라서 컴파일 에러를 일으킨다.

---

4. 인라인(inline) 함수

[매크로 함수의 장점과 함수의 inline 선언]

#define SQUARE(x) ((x)*(x))

int main(void) {
    std::cout << SQUARE(5) << std::endl;
    return 0;
}

 

↓ 선행 처리 결과

int main(void) {
    std::cout << ((5)*(5)) << std::endl;
    return 0;
}

 

• 장점: 함수가 인라인화되어 성능의 향상으로 이어질 수 있다.
• 단점: 함수의 정의 방식이 일반 함수에 비해서 복잡하다. 따라서 복잡한 함수의 정의에는 한계가 있다.

inline 타입 함수이름(매개변수) {
         정의....
}

inline int SQUARE(int x){
    return x*x;
}
int main(void) {
    std::cout << SQUARE(5) << std::endl;
    std::cout << SQUARE(12) << std::endl;
    return 0;
}

 

25
144

 

• 키워드 inline 선언은 컴파일러에 의해서 처리된다. 따라서 컴파일러가 함수의 인라인화를 결정한다.
• inline 선언이 되어도 인라인 처리되지 않을 수 있고, inline 선언이 없어도 인라인 처리될 수 있다.
• 매크로 함수의 장점은 취하고 단점은 보완한 것이 C++의 인라인 함수이다.

 

[인라인 함수에는 없는 매크로 함수만의 장점]

#define SQUARE(x) ((x)*(x))

 

↓ 매크로 함수는 자료형에 독립적이다.

std::cout<< SQUARE(12);    //int형 함수호출
std::cout<< SQUARE(3.15);  //double형 함수호출

 

※ inline 선언된 함수를 위의 형태로 호출하려면, 각 자료형 별로 함수가 오버로딩되어야 한다.

즉, 매크로 함수와 달리 자료형에 독립적이지 못하다.

• inline int SQUARE(int x) { return x*x; }
• int형 기반으로 정의된 함수이기 때문에 데이터 손실이 발생할 수 있다.

---

5.이름 공간에 대한 소개

[이름 공간의 기본 원리]

namespace BestComImpl
{
      // 이름공간 내부
}

namespace BestComImpl{
    void SimpleFunc(void){
        std::cout<<"BestCom이 정의한 함수"<<std::endl;
    }
}

namespace ProgComImpl{
    void SimpleFunc(void){
        std::cout<<"ProgCom이 정의한 함수"<<std::endl;
    }
}
int main(void) {
    BestComImpl::SimpleFunc();   //이름공간 BestComImpl에 정의된 SimpleFunc의 호출
    ProgComImpl::SimpleFunc();   //이름공간 ProgComImpl에 정의된 SimpleFunc의 호출
    return 0;
}

 

• 존재하는 이름 공간이 다르면 동일한 이름의 함수 및 변수를 선언하는 것이 가능하다.
• 프로젝트의 진행에 있어서 발생할 수 있는 이름의 충돌을 막을 목적으로 존재하는 것이 이름 공간이다.
• ※범위 지정 연산자: ::
• 이름공간 :: 함수();

 

[이름 공간 기반의 함수 선언과 정의의 분리]

namespace BestComImpl{
    void SimpleFunc(void);     // 이름공간 생성, 함수 선언
}

namespace ProgComImpl{
    void SimpleFunc(void);
}

int main(void) {
    BestComImpl::SimpleFunc();
    ProgComImpl::SimpleFunc();  // 이름공간 함수 호출
    return 0;
}
// 함수 정의
void BestComImpl::SimpleFunc(void){
    std::cout<<"BestCom이 정의한 함수"<<std::endl;
}

void ProgComImpl::SimpleFunc(void){
    std::cout<<"ProgCom이 정의한 함수"<<std::endl;
}

 

→ 이름 공간 BestComImpl에 위치하는 함수 SimpleFunc의 선언과 정의의 분리

→ 이름 공간 ProgComImpl에 위치하는 함수 SimpleFunc의 선언과 정의의 분리

[이름공간 함수 호출]
이름공간 :: 함수이름();

[이름공간 함수 정의]
타입 이름공간::함수이름(매개변수){
    .... 함수정의....
}

 

[동일한 이름 공간 내에서의 함수 호출]

namespace BestComImpl{
    void SimpleFunc(void);
}
namespace BestComImpl{
    void PrettyFunc(void);
}

 

• 선언된 이름 공간의 이름이 동일하다면, 이 둘은 동일한 이름 공간으로 간주한다.
• 즉, SimpleFunc와 PrettyFunc는 동일한 이름 공간 안에 존재하는 상황이다.

 

void BestComImpl::SimpleFunc(void){
    std::cout<<"BestCom이 정의한 함수"<<std::endl;
    PrettyFunc();       // 동일 이름공간
    ProgComImpl::SimpleFunc();   // 다른 이름공간
}

void BestComImpl::PrettyFunc(void){
    std::cout<<"So Pretty!!"<<std::endl;
}

 

• 이름 공간을 명시하지 않고 함수를 호출하면, 함수의 호출문이 존재하는 함수와 동일한 이름 공간 안에서 호출할 함수를 찾게 된다.
• 따라사 SimpleFunc 함수 내에서는 이름 공간을 명시하지 않은 상태에서 PrettyFunc 함수를 직접 호출할 수 있다.

 

[이름 공간의 중첩]

namespace Parent{      //이름공간 Parent
    int num=2;         //Parent::num
    namespace SubOne{  //Parent::SubOne
        int num=3;     //Parent::SubOne::num 
    }
    namespace SubTwo{  //Parent::SubTwo
        int num=4;     //Parent::SubTwo::num
    }
}

 

호출
std::cout<<Parent::num<<std::endl;
std::cout<<Parent::SubOne::num<<std::endl;
std::cout<<Parent::SubTwo::num<<std::endl;

• 이름 공간은 중첩이 가능하다.
• 따라서 계층적 구조를 갖게끔 이름 공간을 구성할 수 있다.

 

[std::cout, std::cin, std::endl]

std::cout → 이름공간 std에 선언된 cout
std::cin  → 이름공간 std에 선언된 cin
std::endl → 이름공간 std에 선언된 endl

 

namespace std{
    cout...
    cin...
    endl...
}

 

• <iostream>에 선언되어 있는 cout, cin 그리고 endl은 이름 공간 std 안에 선언되어 있다.
• 이렇듯 이름 충돌을 막기 위해서, C++ 표준에서 제공하는 다양한 요소들은 이름 공간 std 안에 선언되어 있다.

 

[using을 이용한 이름 공간의 명시]

#include <iostream>

namespace Hybrid{
	void HybFunc(void){
    	std::cout<<"So simple function!"<<std::endl;
        std::cout<<"In namespace Hybrid!"<<std::endl;
        }
}

int main(void){
	using Hybrid::HybFunc;
    HybFunc;
    return 0;
}

• using 선언을 통해서 이름공간의 지정 없이 HybFunc 함수를 호출하고 있다.

#include <iostream>
using std::cin;
using std::cout;
using std::endl;

int main(void) {
    int num=20;
    cout<<"Hello World!"<<endl;
    cout<<"Hello"<<"World!"<<endl;
    cout<<num<<' '<<'A';
    cout<<' '<<3.14<<endl;
    return 0;
}

 

• using 선언은 전역변수와 마찬가지로 함수 밖에 선언을 해야 함!

• 이후부터 cin, cout, endl은 std::cin, std::cout, std::endl을 의미한다는 선언

 

#include <iostream>
using namespace std;

int main(void) {
    int num=20;
    cout<<"Hello World!"<<endl;
    cout<<"Hello"<<"World!"<<endl;
    cout<<num<<' '<<'A';
    cout<<' '<<3.14<<endl;
    return 0;
}

 

using namespace std;

• 이름 공간 std에 선언된 것은 std라는 이름 공간의 선언 없이 접근하겠다는 선언

 

※너무 빈번한 using namespace의 선언은 이름의 충돌을 막기 위한 이름 공간의 선언을 의미 없게 만든다. 따라서 제한적으로 사용할 필요가 있다.

 

[이름 공간의 별칭 지정과 전역변수의 접근]

namespace AAA{
    namespace BBB{
        namespace CCC{
            int num1;
            int num2;
        }
    }
}

 

namespace ABC=AAA::BBB::CCC;
// AAA::BBB::CCC에 대해 ACC라는 이름의 별칭 선언 후,

ABC::num1=10;
ABD::num2=20;
// 위와 같이 하나의 별칭으로 이름공간의 선언을 대신할 수 있다.

이름공간 별칭: namespace ABC=AAA::BBB::CCC

---

• 지역변수의 이름이 전역변수와 이름과 같을 경우, 전역변수는 지역변수에 의해 가려진다

int val=100; // 전역변수

int SimpleFunc(void){
    int val=20;  // 지역변수
    val+=3;      // 지역변수 val의 값 3 증가
    ::val+=7;    // 전역변수 val의 값 7 증가
}

 

 

• 범위지정 연산자는 지역변수가 아닌 전역변수의 접근에도 사용이 가능하다.

 

int val = 100;  	// 전역변수

int SimpleFunc(void){
	int val = 20;	// 지역변수
    val += 3;		// 지역변수 val의 값 3 증가
    ::val += 7;		// 전역변수 val의 값 7 증가

• 전역변수 접근 → ::변수