[열혈 c++ 프로그래밍] ch1

열혈 c++ 프로그래밍을 보고 요약정리합니다.

1-1 데이터 입출력

• 입력과 출력을 위한 표준 라이브러리 → iostream

  • .h → 과거 표준 라이브러리 or 프로그래머가 정의하는 헤더파일의 선언

    #include <iostream>
    
    int main(void) {
        int val1;
        std::cout<<"첫 번째 숫자 입력: ";
        std::cin>>val1;
        
        int val2;
        std::cout<<"두 번째 숫자 입력: ";
        std::cin>>val2;
        
        int result = val1 + val2;
        std::cout<<"덧셈결과: "<<result<<std::endl;
        return 0;
    }

  • 데이터의 입력도 데이터의 출력에서 별도의 포맷 지정이 필요 없다.

  • 실수형 덧셈을 하고자 한다면, 데이터 타입을 double같은 실수형 변수로 바꿔주면 된다.

  • 다음처럼 연속으로 데이터 입력을 받을 수도 있다.

    std::cin>>val1>>val2; // 두 데이터는 공백(탭, 스페이스바, 엔터 키)에 의해 나눠진다.

  • 배열 기반의 문자열 입출력

    #include <iostream>
    
    int main(void) {
        char name[100];
        char lang[200];
        
        std::cout<<"이름은 무엇입니까?";
        std::cin>>name;
        
        std::cout<<"좋아하는 프로그래밍 언어는 무엇인가요?";
        std::cin>>lang;
        
        std::cout<<"내 이름은 "<<name<<"입니다. \n";
        std::cout<<"제일 좋아하는 언어는 " << lang << "입니다." << std::endl;
        return 0;
    }

1-2 함수 오버로딩

• 매개변수의 자료형 또는 개수가 다르면 동일한 이름의 함수를 정의하는것이 가능하다.

  #include <iostream>
  
  void swap(int*num1, int*num2) {
      int temp = *num1;
      *num1 = *num2;
      *num2 = temp;
      std::cout<<*num1<<std::endl<<*num2;
  }
  
  void swap(char*ch1, char*ch2) {
      char temp = *ch1;
      *ch1 = *ch2;
      *ch2 = temp;
      std::cout<<*ch1<<std::endl<<*ch2;
  }
  
  int main(void) {
      int num1=20, num2=30;
      swap(&num1, &num2);
      std::cout<<'\n';
      
      char ch1 = 'a', ch2 = 'b';
      swap(&ch1, &ch2);
      return 0;
  }

1-3 매개변수의 디폴트 값

#include <iostream>

int MyFunc(int num1=5, int num2=7) { //전달되는 인자는 왼쪽부터 채워나간다.
    return num1 + num2;
}

int main(void) {
    std::cout<<MyFunc()<<std::endl; // 12
    std::cout<<MyFunc(1)<<std::endl; // 8
    
    return 0;
}

1-4 인라인 함수

매크로 함수

#include <iostream>
#define SQUARE(x) ((x)*(x))

int main(void) {
	std::cout<< SQUARE(5) <<std::endl;
	return 0;
}

• 장점: 일반적인 함수에 비해서 실행속도의 이점이 있다.
• 단점: 복잡한 함수를 매크로의 형태로 정의하는데 한계가 있다,

위의 단점을 해결하는게 c++ 인라인 함수

#include <iostream>

inline int SQUARE(int x) {
	return x*x;
}
int main(void) {
	std::cout<<SQUARE(5)<<std::endl;
	std::cout<<SQUARE(12)<<std::endl;
	return 0;
}

• 인라인 함수의 인라인화(함수 호출문을 함수의 몸체가 대체)는 컴파일러에 의해 처리 된다.
  • 따라서 컴파일러는 인라인화가 성능을 악화시킬경우 키워드를 무시해버릴수 있고 일부 함수를 임의로 인라인 처리 하기도 한다.
• 인라인 함수가 대체하지 못하는 매크로 함수의 장점
  • 자유로운 자료형 (java에서 제네릭 같은)

    #define SQUARE(x) ((x) * (x))
    
    std::cout<<SQUARE(12);
    std::cout<<SQUARE(3.15);

  • 이런 경우를 위해서 템플릿을 사용할 수 있음

    #include <iostream>
    template <typename T>
    inline T SQUARE(T x) {
    	return x*x;
    }
    
    int main(void) {
    	std::cout<<SQUARE(5.5)<<std::endl;
    	std::cout<<SQUARE(12)<<std::endl;
    	return 0;
    }

1-5 이름공간에 대한 소개

• 동일한 이름을 공간으로 구분하는것

  #include <iostream>
  
  using namespace std;
  
  namespace BestComImpl
  {
      void SimpleFunc(void) {
          std::cout<<"BestComImpl이 정의한 함수"<<std::endl;
      }
  }
  
  namespace ProgComImpl
  {
      void SimpleFunc(void) {
          std::cout<<"ProgComImpl이 정의한 함수"<<std::endl;
      }
  }
  
  int main()
  {
      BestComImpl::SimpleFunc();
      ProgComImpl::SimpleFunc();
      return 0;
  }

• std::cout, std::cin, std::endl → 모두 std라는 이름 공간안에 선언되어 있는 것
• using을 사용해서 이름 공간을 명시하여 편하게 함수를 호출할 수 있다.

  using Hybrid::HybFunc; //HybFunc은 Hybrid 이름공간에서 찾으라는 선언
  HybFunc();
  return 0;

  using 또한 지역변수, 전역변수처럼 선언된 지역에서만 적용되기 떄문에 프로그램 전체에 적용하기 위해서는 함수밖에 선언해야 한다.

  #include <iostream>
  using std::cin; // using namespace std; 로 간결하게 나타낼수도 있다.
  using std::cout;
  using std::endl;
  
  int main()
  {
      int num=20;
      cout<<"Hello World!"<<endl;
      cout<<"Hello "<<"World!"<<endl;
      cout<<num<<' '<<'A';
      cout<<' '<<3.14<<endl;
      return 0;
  }

• 범위지정 연산자의 또 다른 기능

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

  • 전역변수 val에 접근하려면? → ::val += 7;