오버로딩(Overloading) : 함수의 중복 정의

오버로딩이란 같은 이름의 함수를 호출하더라도 매개변수에 따라 다른 함수가 실행되는 것입니다.

간단히 코드로 작성해 보겠습니다.

#include <iostream>
#include <string>
using namespace std;

inline void Test(int iTest)	{ cout << iTest << endl; }
inline void Test(string strTest){ cout << strTest << endl; }

int main()
{
	Test(1);
	Test("Hello World!");
	return 0;
}

같은 Test라는 함수를 호출하였음에도 

매개변수에 따라 1과 Hello World!가 출력이 되므로

같은 이름으로 다른 기능을 사용할 수 있게 됩니다.

예시로 Sum()으로 두 변수를 더하는 함수인데 (int, int), (int, float), (float, float) ... 을 만들고 싶다면

Sum_IntToInt, Sum_IntToFloat 가 아닌 Sum(int *, int *), Sum(int *, float *)와 같이

매개변수를 다르게 하여 활용이 가능하여 다형성의 예로 들수 있습니다.

오버라이딩 : 함수 재정의

오버라이딩이란 상속관계에서 부모클래스의 함수를 사용하지 않고 자신만의 함수로 재정의하여 사용하는 것을 말합니다.

#include <iostream>
using namespace std;

class Parent
{
public:
	inline void Test(int iTest) { cout << "Parent : " << iTest << endl; }
};

class Child : public Parent
{
public:
	inline void Test(int iTest) { cout << "Child : " << iTest << endl; }
};

int main()
{
	Parent P;
	Child C;
	P.Test(777);
	C.Test(777);
	return 0;
}

다음과 같이 같은 Test를 호출하였지만 자식은 부모의 Test를 재정의하여

자신만의 Test를 가질수 있게 됩니다.

자식에서의 오버라이딩을 할 때에는

• 메소드(함수)의 이름이 같아야 한다.
• 메소드(함수)의 인자 개수, 자료형이 같아야 한다.
• 리턴형이 같아야 한다.
• 재정의시 구현부가 동일하거나 추가되어야 한다.
• 오버라이드하는 함수가 상위(부모) 클래스에 존재하여야 한다.

위의 조건을 지켜야합니다.

이 문제는 tie와 sync_with_stdio를 알려주는 문제같다.

문제 자체는 어렵지 않으니 바로 코드를 첨부하려한다.

#include <iostream>
#include <unordered_map>
#include <string>
using namespace std;
int iSite = 0, iPassWord = 0;

int main()
{
	ios::sync_with_stdio(false);
	cin.tie(0);
	cout.tie(0);

	cin >> iSite >> iPassWord;
	unordered_map<string, string> umap_Site;
	umap_Site.reserve(iSite);

	for (int i = 0; i < iSite; i++)
	{
		string strSite = "";
		string strPass = "";
		cin >> strSite >> strPass;
		umap_Site.emplace(make_pair(strSite, strPass));
	}
	for (int i = 0; i < iPassWord; i++)
	{
		string strFind = "";
		cin >> strFind;
		cout << umap_Site.find(strFind)->second << "\n";
	}
	return 0;
}

Round 함수에 대한 Math 헤더를 추가 안하였다...ㅠ

문제를 읽고 단순 구현문제라고 판단하여 바로 구현을 시작하였다.

int main()
{
	ios::sync_with_stdio(false);
	cin.tie(0);
	cout.tie(0);

	cin >> iNum;
	vMap.resize(iNum);
	for (int i = 0; i < iNum; i++)
		cin >> vMap[i];
	sort(vMap.begin(), vMap.end());
	cout << Sum() << "\n";
	cout << vMap[iNum / 2] << "\n";
	cout << Mode() << "\n";
	cout << vMap.back() - vMap.front() << "\n";
}

Main에 입력과 출력문으로만 구성을 하였고

int Sum()
{
	long long int iSum = 0;
	for (int i = 0; i < iNum; i++)
		iSum += vMap[i];
	return (int)round((float)iSum / (float)iNum);
}

1번 더하기는 각수를 더한 후 round처리로 반올림 처리를 하였다.

round() : 반올림

ceil() : 무조건 올림

floor() : 무조건 내림

Math.h 헤더 선언 필요... (Visual 2022에서 선언없이 실행이 되어 실행 되는줄...)

int Mode()
{
	if (iNum == 1)
		return vMap[0];
	vector<pair<int, int>> vMode;
	vMode.resize(iNum);
	int iCnt = 0;
	while (iCnt < iNum)
	{
		int iTemp = upper_bound(vMap.begin(), vMap.end(), vMap[iCnt])
					- lower_bound(vMap.begin(), vMap.end(), vMap[iCnt]);
		vMode[iCnt] = make_pair(iTemp, vMap[iCnt]);
		iCnt += iTemp;
	}
	sort(vMode.begin(), vMode.end(), cmp);
	int iModeVal = vMode[0].first;
	vector<int> vResultMode;
	vResultMode.reserve(iNum);
	for (int i = 0; i < iNum; i++)
	{
		if(vMode[i].first == iModeVal)
			vResultMode.emplace_back(vMode[i].second);
	}
	if (vResultMode.size() > 1)
		return vResultMode[1];
	else
		return vResultMode.front();
}

최빈값을 이렇게 처리하였지만 고수분들은 더 깔끔하게 하였을것 같다... 너무 더럽다...

먼저 pair<int, int>로 upper_bound와 lower_bound를 사용하여 중첩된 수를 체크 후

최고 개수로 다시 vector를 구성하여

개수가 2개 이상 → 2번째 인자 출력

개수가 1개 → 첫번째 인자 출력

pair에 대한 정렬은 cmp를 정의하여 pair에 대한 비교를 수행하였다.

bool cmp(pair<int, int> pFront, pair<int, int> pBack)
{
	if (pFront.first == pBack.first)
		return pFront.second < pBack.second;
	return pFront.first > pBack.first;
}

pair는 (중첩 개수, 해당 인자 값) 으로 구성하였고

중첩 수가 같다면 인자의 값으로 정렬을 하였다.

아래는 모든 코드입니다.

#include <iostream>
#include <vector>
#include <algorithm>
#include <math.h>
using namespace std;

int iNum = 0;
vector<int> vMap;

int Sum()
{
	long long int iSum = 0;
	for (int i = 0; i < iNum; i++)
		iSum += vMap[i];
	return (int)round((float)iSum / (float)iNum);
}

bool cmp(pair<int, int> pFront, pair<int, int> pBack)
{
	if (pFront.first == pBack.first)
		return pFront.second < pBack.second;
	return pFront.first > pBack.first;
}

int Mode()
{
	if (iNum == 1)
		return vMap[0];
	vector<pair<int, int>> vMode;
	vMode.resize(iNum);
	int iCnt = 0;
	while (iCnt < iNum)
	{
		int iTemp = upper_bound(vMap.begin(), vMap.end(), vMap[iCnt])
					- lower_bound(vMap.begin(), vMap.end(), vMap[iCnt]);
		vMode[iCnt] = make_pair(iTemp, vMap[iCnt]);
		iCnt += iTemp;
	}
	sort(vMode.begin(), vMode.end(), cmp);
	int iModeVal = vMode[0].first;
	vector<int> vResultMode;
	vResultMode.reserve(iNum);
	for (int i = 0; i < iNum; i++)
	{
		if(vMode[i].first == iModeVal)
			vResultMode.emplace_back(vMode[i].second);
	}
	if (vResultMode.size() > 1)
		return vResultMode[1];
	else
		return vResultMode.front();
}

int main()
{
	cin >> iNum;
	vMap.resize(iNum);
	for (int i = 0; i < iNum; i++)
		cin >> vMap[i];
	sort(vMap.begin(), vMap.end());
	cout << Sum() << "\n";
	cout << vMap[iNum / 2] << "\n";
	cout << Mode() << "\n";
	cout << vMap.back() - vMap.front() << "\n";
}