👀 C++ 공부..

2학년 2학기 수강 과목 중 하나인 객체지향 설계에서 C++을 사용하기에, 예습을 목적으로 여름방학에 C++을 공부했었다. 당시에 공부했던 내용들을 정리하여 포스팅 한다.

위키독스를 주로 참조하여 공부했다.

Input, Output, Overloading

#include<iostream>

void helloworld(void);
void helloworld(int a, int b);

int main(void){
    char temp[10];
    int a, b;
    std::cout << "input any string" << std::endl;
    std::cin >> temp;
    std::cout << "you typed : " << temp << std::endl;
    helloworld();
    std::cin >> a;
    std::cin >> b;
    helloworld(a, b);
    return 0;
}

void helloworld(void){
    std::cout << "HelloWorld" << std::endl;
    std::cout << "type two integer to add" << std::endl;
}

void helloworld(int a, int b){
    std::cout << "result : " << a + b << std::endl;
}

input any string
hello!
you typed : hello!
HelloWorld
type two integer to add
3 5
result : 8

cin을 통해 문자열과 정수를 입력받고 cout을 통해 문자열과 두 수의 연산 결과를 출력하도록 했다. 이 때 helloworld함수는 overloading을 통해 인자에 따라 다르게 작동하도록 코드를 짜 활용해보았다.

Default parameter

#include<iostream>

int adder(int a = 1, int b = 2, int c = 3);

int main(void){
    int a, b, c;
    std::cout << "type three integers to add" << std::endl;
    std::cin >> a;
    std::cin >> b;
    std::cin >> c;
    std::cout << "method with default values " << adder() << std::endl;
    std::cout << "method without default values " << adder(a, b, c) << std::endl;
    std::cout << "method with and without default values #1 " <<adder(a) << std::endl;
    std::cout << "method with and without default values #2 " <<adder(a, b) << std::endl;
    std::cout << "method with and without default values #3 " <<adder(a, b, c) << std::endl;
    return 0;
}

int adder(int a, int b, int c){
    return a + b + c;
}

type three integers to add
7 8 9
method with default values 6
method without default values 24
method with and without default values #1 12
method with and without default values #2 18
method with and without default values #3 24

default parameter라는 처음보는 특성이 있었다. 함수를 선언할 때 미리 인자로 값을 주면, 인자로 해당 부분의 값을 넣지 않았을 때 기본으로 주어진 인자가 자리를 대신한다. 결과를 보면, 인자 없이 실행된경우엔 기본인자인 1, 2, 3이, 입력한 인자를 넣어주면 해당부분은 입력한 인자로, 입력되지 않은 인자는 기본인자로 연산되는것을 확인할 수 있다.

Macro function

#include<iostream>

#define SQUARE(X) ((X)*(X))

int main(void){
    int a;
    std::cout << "type any integer to square" << std::endl;
    std::cin >> a;
    std::cout << "result : " << SQUARE(a) << std::endl;
    return 0;
}

type any integer to square
3
result : 9

C에서와 마찬가지로 macro로 전처리한 구문을 함수처럼 사용할 수 있다.

Inline function

#include<iostream>

inline void helloWorld();

int main(void){
    helloWorld();
    return 0;
}

inline void helloWorld(){
    std::cout << "Hello World!" << std::endl;
}

Hello World!

inline function은 실제로 함수를 실행하는 대신, 함수 안의 명령을 함수와 치환해서 실행한다. 함수의 메모리영역인 stack메모리를 참조하며 발생할 수 있는 시간낭비를 줄여줄 수 있다. 매크로는 전처리기가 처리하지만 inline function은 컴파일러가 처리를 한다. 전달되는 인자도 차이가 있는데, 매크로는 자료형의 제한이 없지만 inline function은 자료형을 정해줄 수 있다는 것이다. 요즘엔 컴파일러가 알아서 인라인시 성능 향상여부를 판단해 처리하기때문에 크게 의미있지는 않다.

String and template

#include<iostream>
using std::string;

template <typename T>

T adder(T a, T b){
    return a + b;
}

int main(void){
    int a, b;
    string c, d;
    std::cout << "type two integers" << std::endl;
    std::cin >> a;
    std::cin >> b;
    std::cout << "you typed " << a << " and " << b << " the result is " << adder<int>(a, b) << std::endl;
    std::cout << "type two strings" << std::endl;
    std::cin >> c;
    std::cin >> d;
    std::cout << "you typed " << c << " and " << d << " the result is " << adder<string>(c, d) << std::endl;
    return 0;
}

type two integers
8 11
you typed 8 and 11 the result is 19
type two strings
hello world
you typed hello and world the result is helloworld

template은 Java의 generic과 같다. 함수나 클래스의 선언시에 자료형을 명시하는것이 아니라, 사용할 때 명시하여 다양한 변수, 객체에 대응하여 작동하도록 해준다. 예제에서 함수 adder는 정수와 문자열에 대해 더하기 연산을 수행하고 그 결과를 보여준다.

Namespace

#include<iostream>

using std::cin;
using std::cout;
using std::endl;

namespace parents{
    void func();
    namespace son{
        void func();
    }
    namespace daughter{
        void func();
    }
}

std::string test = "GLOBAL";                                                    //VARIABLES CAN BE DEFINENED WITH SAME NAME BOTH GLOBALLY AND LOCALLY

int main(void){
    std::string test = "LOCAL";
    
    cout << test << endl;
    cout << ::test <<endl; 
    
    parents::func();
    parents::son::func();
    parents::daughter::func();
    
    namespace seunghun = parents::son;                                          //NEW NAMESPACE CAN BE DEFINED
    seunghun::func();
    
    using namespace parents;
    func();
    son::func();
    daughter::func();
    
    return 0;
}

void parents::func(){
    cout << "PARENTS" << endl;
}

void parents::son::func(){
    cout << "SON" << endl;
}

void parents::daughter::func(){
    cout << "DAUGHTER" << endl;
}

LOCAL
GLOBAL
PARENTS
SON
DAUGHTER
SON
PARENTS
SON
DAUGHTER

namespace는 scope를 분리하여 동일한 이름을 갖는 변수나 함수가 다른 namespace에 존재할 수 있도록 해준다. namespace를 명시하여 다른 scope에 존재하는 코드를 사용할 수 있다. 만약 명시하지 않으면 동일한 scope에 존재하는 변수나 함수를 사용하게된다. using을 사용하여 namespace명시를 생략해줄 수 있다.

Basic reference

#include<iostream>

using std::cin;
using std::cout;
using std::endl;

void swap(int& a, int& b);

int main(void){
    int num1 = 10;
    int& num2 = num1;
    int num3 = 20;
    
    cout << num1 << endl;
    cout << num2 << endl;
    cout << num3 << endl;
    cout << &num1 << endl;
    cout << &num2 << endl;
    cout << &num3 << endl;
    
    num1++;
    cout << num1 << endl;
    cout << num2 << endl;
    cout << num3 << endl;
    cout << &num1 << endl;
    cout << &num2 << endl;
    cout << &num3 << endl;
    
    swap(num1, num3);
    cout << num1 << endl;
    cout << num2 << endl;
    cout << num3 << endl;
    cout << &num1 << endl;
    cout << &num2 << endl;
    cout << &num3 << endl;
    return 0;
}

void swap(int& a, int& b){
    int temp = b;
    b = a;
    a = temp;
}

10
10
20
0x7ffe09549080
0x7ffe09549080
0x7ffe09549084
11
11
20
0x7ffe09549080
0x7ffe09549080
0x7ffe09549084
20
20
11
0x7ffe09549080
0x7ffe09549080
0x7ffe09549084

자료형 뒤에오는 &는 reference를 의미한다. 같은 메모리공간에 할당된 값에 다른 변수 명을 붙여주는 것이다. 이명이나 별명이라고 생각하면 된다. 두개의 변수지만 같은 메모리를 참조한다. 따라서 값이 변경되면 참조하는 값도 변한다. 주소연산자 &와는 다르다! 참조를 이용해 함수를 짜면 스택영역에 매개변수를 위한 메모리를 별도로 할당하지 않고 실제 변수에 직접 접근해서 더 효율적이다.

Return reference

#include <iostream>

using namespace std;

int& RefRetFunc2(int& ref){
    ref++;
    return ref;
}

int main(void){
    int num1 = 1;
    int num2 = RefRetFunc2(num1);
    int& num3 = num1;
    int& num4 = num2;

    cout << "num1: " << num1 << endl;
    cout << "num2: " << num2 << endl;
    cout << "num3: " << num3 << endl;
    cout << "num4: " << num4 << endl;
    cout << "num1: " << &num1 << endl;
    cout << "num2: " << &num2 << endl;
    cout << "num3: " << &num3 << endl;
    cout << "num4: " << &num4 << endl;

    num1 += 2;
    num2 += 100;

    cout << "num1: " << num1 << endl;
    cout << "num2: " << num2 << endl;
    cout << "num3: " << num3 << endl;
    cout << "num4: " << num4 << endl;
    cout << "num1: " << &num1 << endl;
    cout << "num2: " << &num2 << endl;
    cout << "num3: " << &num3 << endl;
    cout << "num4: " << &num4 << endl;

    return 0;
}

num1: 2 num2: 2 num3: 2 num4: 2 num1: 0x7ffcb81482f4 num2: 0x7ffcb81482f8 num3: 0x7ffcb81482f4 num4: 0x7ffcb81482f8 num1: 4 num2: 102 num3: 4 num4: 102 num1: 0x7ffcb81482f4 num2: 0x7ffcb81482f8 num3: 0x7ffcb81482f4 num4: 0x7ffcb81482f8

reference를 반환하도록 함수를 짤 수 있다. 참조를 반환하거나 일반 변수에 참조변수를 집어넣게되면 참조 변수가 가진 값이 복사된다. 위의 예제를 보면, num1의 reference에 1을 더해 num2로 전달하여 num1과 num2모두 2가된다. 그리고 그 값을 reference로 가져가는 num3와 num4도 값이 변한다. 이후에 num1에 2를 더하여 num1과 그를 참조하는 num3의 값은 4가 되고, num2에 100을 더하여 num2와 그를 참조하는 num4는 102가 된다.

Conventional malloc and free methods

#include<iostream>
#include<string.h>

char* createString(int length);

using std::cout;
using std::endl;

int main(void){
    char* myString = createString(20);
    strcpy(myString, "I AM SO HAPPY");
    cout << myString << endl;
    cout << &myString << endl;
    free(myString);
    cout << myString << endl;
    cout << &myString << endl;
    return 0;
}

char* createString(int length){
    char* newString = (char*)malloc(sizeof(char) * length);
    return newString;
}

I AM SO HAPPY
0x7ffea83500a8

0x7ffea83500a8

C언어에서 사용하는 전통적인 malloc과 free은 C++에서도 그대로 사용 가능하다.

… are replaceable with new and delete in C++

#include<iostream>
#include<string.h>

char* createString(int length);

using std::cout;
using std::endl;

int main(void){
    char* myString = createString(20);
    strcpy(myString, "I AM SO HAPPY");
    cout << myString << endl;
    cout << &myString << endl;
    delete[](myString);
    cout << myString << endl;
    cout << &myString << endl;
    return 0;
}

char* createString(int length){
    char* newString = new char[length];
    return newString;
}

I AM SO HAPPY
0x7ffea83500a8

0x7ffea83500a8

C++에서는 malloc과 free를 대체하는 new와 delete가 있다. 결과는 위와 동일함을 확인할 수 있다.

다음 글 📚 혼자하는 C++ 공부 -2- 보러가기