모각코 3회차 결과

▷ using을  이용한  이름공간의  명시

#include <iostream>
using std::cin;
using std::cout;
using std::endl;
//이후부터 cin, cout, endl은 std::cin, std::cout, std::endl을 의미하는 선언
//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;
}

 

 

 

▷ 이름 공간의 별칭 지정 전역변수의 접근

#include <iostream>
namespace AAA
{
    namespace BBB
    {
        namespace CCC{
            int num1;
            int num2;
        }
    }
}
namespace ABC=AAA::BBB::CCC;

int val = 100;

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

    return val;
}

int main(void)
{
    ABC::num1=10;
    ABC::num2=20;
    std::cout<<ABC::num1<<" "<<ABC::num2<<std::endl; 
    std::cout<<SimpleFunc()<<" "<<val<<std::endl;
}

실행 결과

 

ch02 c언어 기반의 c++ 2

 

02-1

 

▷ c언어에서 const의 의미

const int num = 10; //변수 num 상수화
const int * ptr1 = &val1; //포인터 ptr1을 이용해 val1의 값 변경 불가
int * const ptr2 = &val2; //포인터 ptr2가 상수화
const int * const ptr3 = &val3; //포인터 ptr3가 상수화, ptr3 이용해 val3의 값 변경 불가

 

 

02-2 새로운 자료형 bool

 

▷ true, false

int num1 = true; //1
int num2 = false; //0
int num3 = true+false; //1+0

sizeof(true) //1

 

▷ 자료형 bool

//true와 false => bool형 데이터
//true와 false 정보를 저장할 수 있는 변수는 bool형 변수
#include <iostream>
using namespace std;


bool IsPositive(int num)
{
    if(num<0)
        return false;
    else
        return true;

}


int main(void)
{
    bool isPos;
    int num;
    cout<<"Input number: ";
    cin>>num;
    isPos=IsPositive(num);
    
    if(isPos)
        cout<<"Positive numer"<<endl;
    else
        cout<<"Negative number"<<endl;

    return 0;

}

실행 결과

 

02-3 참조자의 이해

int num = 2024;
int &num2 = num1;

 

참조자의 선언으로 num1의 메모리 공간에 num2라는 이름이 추가로 붙게 됨

참조자==기존에 선언된 변수에 붙이는 별칭

 

 

▷ 참조자 예제, 참조자 선언

#include <iostream>
using namespace std;

int main(void)
{
    int num1 = 1020;
    int &num2 = num1; //num2는 num1의 참조자
    //num1으로 하는 모든 연산은 num2로 하는 것과 동일한 결과
    num2 = 3047;
    cout<<"VAL: "<<num1<<endl;
    cout<<"REF: "<<num2<<endl;
    cout<<"VAL: "<<&num1<<endl;
    cout<<"REF: "<<&num2<<endl;

    return 0;

}
참조자의 수 제한 X

실행 결과

 

▷ 참조자의 선언 가능 범위

int &ref = 20; //상수 대상으로 참조자 선언 불가능
int &ref; //생성과 동시에 누군가를 참조해야 함
int &ref=NULL; //포인터처럼 NULL 초기화도 불가능

#include <iostream>

using namespace std;

int main(void)
{
    int arr[3] = {1,3,5};
    int &ref1 = arr[0]; //배열의 요소는 변수의 성향 지니기 때문에 참조자 선언 가능
    int &ref2 = arr[1];
    int &ref3 = arr[2];

    cout<<ref1<<endl;
    cout<<ref2<<endl;
    cout<<ref3<<endl;

    return 0;
}

실행 결과

 

▷ 포인터 변수 대상의 참조자 선언

#include <iostream>

using namespace std;

int main(void)
{
    int num=12;
    int *ptr=&num;
    int **dptr = &ptr;

    int &ref=num;
    int *(&pref)=ptr;
    int **(&dpref)=dptr;
    cout<<ref<<endl;
    cout<<*pref<<endl;
    cout<<**dpref<<endl;

    return 0;
}

실행 결과

 

02-4 참조자와 함수

 

▷ 참조자를 이용한 call-by-value

#include <iostream>

using namespace std;

void SwapByRef2(int &ref1,int &ref2)
{
    int temp=ref1;
    ref1=ref2;
    ref2=temp;
} //Call-by-reference

int main(void)
{
    int val1=10;
    int val2=20;
    SwapByRef2(val1,val2);
    cout<<"val1: "<<val1<<endl;
    cout<<"val2: "<<val2<<endl;
    
    return 0;
}

실행 결과

 

▷ const 참조자

void HappyFunc(const int &ref){...} // 함수 내에서 ref를 이용한 값의 변경 허용 X

 

 

▷ 반환형이 참조이고 반환도 참조로 받는 경우

#include <iostream>

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

int main(void){
    int num1 = 1;
    int &num2 = RefRetFuncOne(num1);
    
    num1++;

    std::cout<<"num1: "<<num1<<std::endl;
    std::cout<<"num2: "<<num2<<std::endl;
    return 0;
}

실행 결과

 

 

▷ 반환형이 참조이되 반환은 변수로 받는 경우

#include <iostream>

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

int main(void){
    int num1 = 1;
    int num2 = RefRetFuncOne(num1);

    num1++;
    num2+=100;

    std::cout<<"num1: "<<num1<<std::endl;
    std::cout<<"num2: "<<num2<<std::endl;
    return 0;
}

실행 결과

 

▷ 참조를 대상으로 값을 반환하는 경우

int num2 = RefRetFuncOne(num1);
int &num2 = RefRetFuncOne(num1);

 

반환형이 참조형인 경우 → 반환되는 대상을 참조자 또는 변수로 받을 수 있음

반환형이 값의 형태 →  참조자로 그 값을 받을 수 없음

 

 

▷ 잘못된 참조의 반환

int& RetuRefFunc(int n)
{
	int num=20;
    num+=n;
    return num;
}

int &ref = RetuRefFunc(10);//error의 원인, ref가 참조하는 대상이 소멸

 

 

▷ const 참조자의 또 다른 특징

const int num = 20;
int &ref=num; //error의 원인, 이를 허용한다는 것은 ref를 통한 값의 변경 허용한다는 뜻, const로 선언하는 이유가 ...
ref+=10;
cout<<num<<endl;

 

↓

const int num=20;
const int &ref=num;
const int &ref=50;
//const 사용을 빈번히 하는 것은 좋음

 

 

▷ 어떻게 참조자가 상수를 참조?

const int &ref=30;

상수를 메모리에 임시적으로 저장하기 때문에 행을 바꿔도 소멸하지 않음

 

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

매개변수 형이 참조자인 경우에 상수를 전달할 수 있도록 하기 위함임

 

 

02-5 malloc&free 를 대신하는 new&delete

 

▷ new&delete

int * ptr1 = new int;
double * ptr2 = new double;
int * arr1 = ne wint[3];
double * arr2 = new double[7];

malloc 대신 메모리의 동적 할당 방법임. 크기를 바이트 단위로 계산하는 일을 거치지 않아도 됨.

 

delete ptr1;
delete ptr2;
delete []arr1;
delete []arr2;

free를 대신하는 메모리의 해제 방법

 

 

▷ 포인터를 사용하지 않고 힙에 접근하기

int *ptr = new int;
int &ref=*ptr; //힙 영역에 할당된 변수에 대한 참조자 선언
ref=20;
cout<<*ptr<<endl; //20

변수의 성향을 지니는(값 변경 가능) 대상에 대해 참조자의 선언이 가능

 

 

 

02-6 c++에서 c언어의 표준 함수 호출하기

 

▷ c++ 표준헤더: c를 더하고 .h 빼기

#include <stdio.h> -> #include <cstdio>
#include <stdlib.h> -> #include <cstdlib>
#include <math.h> -> #include <cmath>
#include <string.h> -> #include <cstring>

 

 

 

 

ch03 클래스의 기본

 

03-1 c++에서의 구조체

 

구조체 - 연관 있는 데이터를 하나로 묶는 문법적 장치

 

▷ c++에서의 구조체 변수 선언

struct Car
{
	char gamerID[ID_LEN];
    int fuelGauge;
    int curSpeed;
};

void ShowCarState(const Car &car){...}
void Accel(Car &car){...}
void Break(Car &car){...}

c++에서는 구조체 변수 선언시 struct 키워드의 생략을 위한 typedef 선언 불필요

 

▷ 구조체 안에 함수 삽입하기

struct Car
{
	char gamerID[ID_LEN];
    int fuelGauge;
    int curSpeed;
    
    void ShowCarState(const Car &car)
    {
    	cout<<gamerID<<endl;
        cout<<fuelGauge<<"%"<<endl;
        cout<<curSpeed<<"km/s"<<endl<<endl;
    
    }
    
	void Accel(Car &car){...}
    
	void Break(Car &car)
    {
    	if(curSpeed<BRK_STEP)
        {
        	curSpeed=0;
            return;
        }
        
        curSpeed -= BRK_STEP;
    }
};

c++에서는 구조체 안에 함수를 삽입하는 것이 가능. 따라서 c++에서는 구조체가 아닌 클래스라고 한다.

 

 

▷ c++에서의 구조체 변수 선언

Car run99 = {"run99",100,0};
Car Sped77={"sped77",100,0};

 

▷ 구조체 안에 enum 상수의 선언

struct Car
{
	enum
    {
    	ID_LEN=20;
        MAX_SPD=200;
        FUEL_STEP=2;
        ACC_STEP=10;
        BRK_STEP=10;
    };

	char gamerID[ID_LEN];
    int fuelGauge;
    int curSpeed;

	void ShowCarState(const Car &car){...}
	void Accel(Car &car){...}
	void Break(Car &car){...}
};

구조체 안에 enum 선언을 함으로써 잘못된 외부의 접근 제한

 

▷ 함수는 외부로 뺄 수 있음

struct Car
{
	...
    void ShowCarState(); //구조체 안에 삽입된 함수의 선언
    void Accel();
    ...
};

void Car::ShowCatState() // 구조체 밖에 선언된 함수의 정의
{
	...
}
void Car::Accel()
{
	...
}

 

 

03-2 클래스와 객체

 

▷ 클래스와 구조체의 유일한 차이점

class Car{...}

struct 대신해 class 사용한 것이 유일한 외형적 차이점

int main(void)
{
	Car run99;
    strcpy(run99.gamerID,"run99");
    run99.fuelGauge=100;
    run99.curSpeed=0;
    ....
}

위와 같이 단순히 키워드만 class로 바꾸면 선언된 멤버에 접근 불가능.

별도의 접근 제어와 관련된 선언 추가해야 함.

 

▷ 접근제어 지시자

public 어디서든 접근 허용
protected 상속 관계에 놓였을 때, 유도 클래스에서의 접근 허용
private 클래스 내에서만 접근 허용

 

class Car
{
private:
	
    char gamerID[CAR_CONST::ID_LEN];
    int fuelGauge;
    int curSpeed;
    
public:
	
    void InitMembers(char*ID,int fuel);
    void ShowCarState();
    void Accel();
    void Break();
};

int main(void)
{
	Car run99
    run99.InitMembers("run99",100);
    run99.Accel();
    run99.Accel();
    run99.Accel();
    run99.ShowCarState();
    return 0;
}