c++ 함수 중첩, 디폴트 인자

객체지향 언어의 특징을 담은 소스

#include <iostream>
#include <string>

// 클래스 정의: 캡슐화와 관련된 예제
class Animal {
private:
    std::string name;

public:
    // 생성자
    Animal(std::string n) : name(n) {}

    // 멤버 함수: 캡슐화를 통해 내부 상태에 접근
    std::string getName() const {
        return name;
    }

    void setName(std::string n) {
        name = n;
    }

    // 가상 함수: 다형성(polymorphism)을 위한 예제
    virtual void makeSound() const {
        std::cout << "동물 소리" << std::endl;
    }
};

// 상속: Animal 클래스를 상속받는 Dog 클래스 정의
class Dog : public Animal {
public:
    // 생성자에서 부모 클래스의 생성자 호출
    Dog(std::string n) : Animal(n) {}

    // 오버라이딩: 부모 클래스의 가상 함수를 재정의
    void makeSound() const override {
        std::cout << "멍멍" << std::endl;
    }
};

int main() {
    // 다형성을 통해 동적 바인딩
    Animal* myAnimal = new Dog("멍멍이");
    myAnimal->makeSound();

    // 캡슐화를 통한 멤버 변수 접근
    std::cout << "동물의 이름: " << myAnimal->getName() << std::endl;

    // 메모리 누수 방지를 위한 삭제
    delete myAnimal;

    return 0;
}

다형성이란?

 

다형성(polymorphism)은 객체지향 프로그래밍에서 여러 개체(클래스)들이 동일한 인터페이스(메서드 또는 함수)를 공유하면서도 각 객체가 다르게 동작할 수 있는 능력을 말합니다. C++에서는 주로 가상 함수(virtual functions)와 포인터 또는 참조를 사용하여 다형성을 구현합니다.

함수 오버로딩(중첩)

 

같은 이름의 함수를 여려개 사용 할 수 있다.

함수 오버로딩 예제 소스

#include <iostream>
int add(int i, int j)
{
	return (i + j);
}
double add(double i, double j)
{
	return (i + j);
}
int main()
{
	std::cout << add(10, 20) << std::endl;
	std::cout << add(10.5, 20.3) << std::endl;

	return 0;
}

컴파일러가 실매개변수의 입력 자료형과 매개변수의 개수에 따라서 자동적으로 해당 함수를 연결해준다.

double add(int i, int j)
{
return ((double)i+(double)j);
}

 

위 함수는 리턴형은 다르지만 매개변수가 같기 때문에 중첩이 불가능하다. 

생성자 중첩

#include <iostream>
class Dog {
private:
	int age;
public:
	Dog() { age = 1; } // 매개변수가 없는 생성자, 자동 inline
	Dog(int a) { age = a; } // 매개변수가 하나인 생성자
	~Dog();
	int getAge();
	void setAge(int a);
};
Dog::~Dog()
{
	std::cout << "소멸";
}
int Dog::getAge()
{
	return age;
}
void Dog::setAge(int a)
{
	age = a;
}
int main()
{
	Dog happy(4), meri;
	std::cout << happy.getAge() << "," << meri.getAge();
	return 0;
}

클래스의 생성자도 함수이기 때문에 중첩이 가능하다

happy는 매개변수값으로 4를 줬기 떄문에 4로 초기화가 되고 meri는 값을 주지 않았기 때문에 1로 초기화된다.

생성자 함수를 중첩시키는 것은 객체에 초기값을 다양하게 주는 선택 기회를 제공하는 것이다.

디폴트 인자

#include <iostream>
int add(int i=1, int j=2) // 형식매개변수
{
	return(i + j);
}
int main()
{
	std::cout << add() << ","; // 실매개변수 없음, 3
	std::cout << add(10) << ","; // 실매개변수 한 개, 12
	std::cout << add(10, 20); // 실매개변수 두개, 30
	return 0;
}

add()나 add(10)처럼 호출을 하면 원래는 오류가 나야 하지만 디폴트 인자로 i=2 j=2 값을 줬기 때문에 

3과 12라는 값이 나오게 된다.

add(10,20)처럼 인자에 모두 값을 전달하게 되면 디폴트 인자는 무시되어서 30이 나온다.

 

일단 디폴트 매개변수를 정의하기 시작하면 그 다음(오른쪽)의 매개변수들은 모두 디폴트 매개변수를 가져야 한다.

 int add(int i=1, int j);//오류

 int add(int i, int j=1);//오류 X

 

#include <iostream>
int add(int i = 1, int j = 2);//선언
int main()
{
	std::cout << add() << ","; // 실매개변수 없음, 3
	std::cout << add(10) << ","; // 실매개변수 한 개, 12
	std::cout << add(10, 20); // 실매개변수 두개, 30
	return 0;
}
int add(int i, int j) //함수 정의
{
	return(i + j);
}

위 소스처럼 main함수 위에 선언을 하게 되면 선언 부분에만 디폴트 인자를 지정해야 하며, 함수 정의 부분에는 디폴트 인자를 지정하지 않는다.

디폴트 인자를 갖는 생성자

#include <iostream>
class Dog {
private:
	int age;
public:
	Dog(int a=1) { age = a; }
	// 디폴트 매개변수를 갖는 생성자 
	//Dog() {age=1}을 쓰는것과 같은 기능을 함
	~Dog();
	int getAge();
	void setAge(int a);
};
Dog::~Dog()
{
	std::cout << "소멸\n";
}
int Dog::getAge()
{
	return age;
}
void Dog::setAge(int a)
{
	age = a;
}
int main()
{
	Dog meri, happy(5);
	std::cout << happy.getAge() << "," <<meri.getAge() << std::endl;
	return 0;
}

디폴트 매개변수(인자)의 사용은 함수 중첩의 축약형이다. Dog(int a=1)로 디폴트 인자를 주는 것은

Dog(){age=1;}과 같은 의미이기 때문에 둘 중 하나만을 써야 한다.

생성자를 class 외부에 정의한 소스

#include <iostream>
class Dog {
private:
	int age;
public:
	Dog(int a = 1);
	~Dog();
	int getAge();
	void setAge(int a);
};
Dog::Dog(int a) 
{ age = a; }
Dog::~Dog()
{
	std::cout << "소멸\n";
}
int Dog::getAge()
{
	return age;
}
void Dog::setAge(int a)
{
	age = a;
}
int main()
{
	Dog meri, happy(5);
	std::cout << happy.getAge() << "," <<
		meri.getAge() << std::endl;
	return 0;
}

생성자를 class 외부에 정의한 소스