[C++] 함수, 참조자, 디폴트 인수, 함수 오버로딩, 함수 오버라이딩, 인라인 함수

💡 함수 포인터 

: 함수의 이름 == 메모리에 올라간 함수의 시작 주소를 가리키는 포인터 상수

void (*ptr_func)(int, int);

: 함수를 또 다른 함수의 인수로 전달할때 유용

 

💡 참조자 reference

: 크기가 큰 구조체와 같은 데이터를 함수의 인수로 전달할 때 사용

: 참조자를 이용해 연산을 수행 -> 참조 변수 뿐만 아니라 대상 변수도 변경

int x = 10; // 변수의 선언
int& y = x; // 참조자 선언

cout << "x : " << x << ", y : " << y << endl;
y++;        // 참조자를 이용한 증가 연산
cout << "x : " << x << ", y : " << y << endl;
cout << "x의 주소값 : " << &x << ", y의 주소값 : " << &y;

: & 타입을 식별하기 위해 식별자로 사용

ex) int& : int형 변수에 대한 참조

❗ 참조자의 타입은 대상이 되는 변수의 타입과 일치해야한다.

❗ 선언과 동시에 초기화가 되어야한다.

❗ 한번 초기화되면, 참조하는 대상을 변경할 수 없다.

 

💡 참조자 : 함수의 인수로서 전달

: 함수가 참조자를 인수로 전달받으면, 참조자가 참조하고 있는 실제 변수의 값을 함수 내에서 조작함

int main(void)
{
    int num1 = 3, num2 = 7;
    cout << "변경 전 num1의 값은 " << num1 << "이며, num2의 값은 " << num2 << "입니다." << endl;
    Swap(num1, num2);
    cout << "변경 후 num1의 값은 " << num1 << "이며, num2의 값은 " << num2 << "입니다." << endl;

    return 0;
}

void Swap(int& x, int& y)
{
    int temp;

    temp = x;
    x = y;
    y = temp;
}

 

💡 구조체의 참조

: 참조를 사용하는 이유가 구조체의 참조가 많다

struct Book
{
    string title;
    string author;
    int price;
};

void Display(const Book&);

int main(void)
{
    Book web_book = {"HTML과 CSS", "홍길동", 28000};
    Display(web_book);

    return 0;
}

void Display(const Book& bk)
{
    cout << "책의 제목은 " << bk.title << "이고, ";
    cout << "저자는 " << bk.author << "이며, ";
    cout << "가격은 " << bk.price << "원입니다.";
}

 

💡 디폴트 인수 

: 기본값이 미리 정의되어 있는 인수

1. 함수의 원형에만 지정할 수 있다.

2. 가장 오른쪽부터 시작하여 순서대로만 지정할 수 있다

3. 가운데 인수들만 별도로 디폴트 인수를 지정할 수는 없다.

: 함수로 전달된 인수는 왼쪽부터 순서대로 매개변수 목록에 대입된다

: 인수의 전달을 건너뛸 수 없다 

void Display(int x, int y, char ch = 'a', int z = 4); // 함수의 원형

1. Display(1, 2);         // 가능함 -> display(1, 2, 'a', 4)와 같음.
2. Display(3, 4, 'b');    // 가능함 -> display(3, 4, 'b', 4)와 같음.
3. Display(5, 6, 'c', 9); // 가능함 -> display(5, 6, 'c', 8)와 같음.
4. Display(7, 8, , 9);    // 오류 : 인수 전달은 건너뛸 수 없음.

 

💡 함수 오버로딩

: 같은 이름의 함수를 중복하여 정의 -> 각 함수마다 매개변수가 다르다

: 여러 함수를 하나의 이름으로 연결

: 같은 일을 처리하는 함수를 매개변수의 형식을 조금씩 달리하여, 하나의 이름으로 작성하게 함

: == 다형성의 구성

: 오버로딩된 함수를 호출하면 같은 시그니처를 가지는 함수의 원형을 찾아 호출한다.

1. void Display(const char* str, int n);             // 문자열 str을 n번 출력함.
2. void Display(const char* str1, const char* str2); // 문자열 str1과 str2를 연달아 출력함.
3. void Display(int x, int y);                       // x * y를 출력함.
4. void Display(double x, double y);                 // x / y를 출력함.

Display("C++", 3);              // 1번 Display() 함수 호출 -> "C++C++C++"
Display("C++", " Programming"); // 2번 Display() 함수 호출 -> "C++ Programming"
Display(3, 4);                  // 3번 Display() 함수 호출 -> 12
Display(4.2, 2.1);              // 4번 Display() 함수 호출 -> 2
Display(4.2, 3);                // 3번과 4번 모두 호출 가능 -> 컴파일 오류가 발생함.

 

💡 함수 오버라이딩

: 이미 정의된 함수를 무시하고, 같은 이름의 함수를 새롭게 정의하는 것

: 멤버 함수의 동작만을 재정의하는 것, 함수의 원형은 기존 멤버 함수의 원형과 같아야한다.

☞ 파생 클래스에서 직접 오버라이딩

void Person::ShowPersonInfo()	// Person 클래스
{
    cout << name_ << "의 나이는 " << age_ << "살입니다." << endl;
}

...

void Student::ShowPersonInfo()	// Student는 Person의 파생클래스
{
	// 재정의한 함수
    cout << "이 학생의 학번은 " << student_id_ << "입니다." << endl;
}

Student kim(20220920, "사람", 20);
kim.ShowPersonInfo();
// 파생 클래스에서 기초 클래스의 원래 멤버 함수 호출
kim.Person::ShowPersonInfo();

* Student 객체는 자신이 재정의한 ShowPersonInfo() + 기초 클래스의 원래 함수 둘다 호출

 

 

💡 인라인 함수

: 함수 호출 -> (스택) 매개변수, 호출 끝난뒤 돌아갈 주소값 저장 -> (스택)지역 변수 저장 -> 호출 끝난뒤 저장된 주소값으로 돌아간뒤 -> 스택에 저장된 함수 정보 제거

 : 호출될 때 함수의 모든 코드를 호출된 자리에 바로 삽입하는 방식

: 함수 호출시간 절약, 호출 과정으로 생기는 여러가지 이점 포기

inline int Sub(int x, int y) 
{ 
	return x - y; 
}

inline void Print(int x) 
{ 
	cout << "계산 결과는 " << x << "입니다."; 
}

int main(void)
{
    int num1 = 5, num2 = 3;
    int result;
    result = Sub(num1, num2);
    Print(result);

    return 0;
}

 

💡 매크로 함수

: #define 함수의 정의

: 모든 인수를 괄호({})로 감싸야한다.

#include <stdio.h>
#define SQR(X) X*X

int main(void)
{
    int result;
    int x = 5;

    puts(SQR(10));	// 100
    puts(SQR(x));	// 25
    puts(SQR(x+3));	// 23
    
    return 0;
}