[C++] 문법 기초

Vaughan·2022년 7월 13일
cpp프로그래밍언어
0

C++

목록 보기
1/6
post-thumbnail

1. 새로운 입출력 방식

01-Hello World! 살펴보기

#include <iostream>
int main(){
    
    std::cout<<"Hello World!"<<std::endl;
    std::cout<<"Hello "<<"World!"<<std::endl;
    std::cout<<"Hello World!\n";
    
    return 0;
}
  • C언어에서 사용하던 <stdio.h>가 아니라 <iostream>이라는 헤더파일을 추가한다.
    • 표준 입출력 라이브러리
    • 확장자 .h를 표시하지 않는이유? : 과거의 라이브러리는 iostream.h, 새로운 라이브러리는 iostream
  • std::cout 을 이용해서 출력한다.
  • std::endl 을 이용해서 개행한다.
    (개행문자 \n을 이용해 개행할 수도 있다.)

02-출력 cout

std::cout<<출력대상;

출력대상을 terminal에 출력

  • 출력대상은 문자열, 문자, 정수, 실수 등 어떤 자료형이든 올 수 있다.
  • C언어와 달리 출력할 때 형식지정자를 사용하지 않아도 된다.
    *형식지정자 : %d, %f…
  • 출력 대상 뒤에 << std::endl 을 이용해서 개행할 수 있다.
    → endl : endline이라는 의미

03-입력 cin

  • 입력 형식

    int num;  
std::cout<<"입력안내문";
std::cin>>num;

    사용자로부터 입력받은 정수를 변수 num 에 저장

    • cin으로부터 입력받은 값을 다음 변수에 대입한다는 의미.
    • C언어와 달리 입력할 때도 형식지정자를 사용하지 않아도 된다.
      입력은 값을 저장하는 변수의 자료형에 따라 자동으로 처리됨
    • 출력에 사용하는 화살표 방향(<<)과 헷갈리지 않도록 주의
    • C++에서는 변수선언의 위치에 제한을 두지 않는다.

  • 여러개의 입력 받기

    int numA, numB;
std::cin>>numA>>num2;

    사용자로부터 첫번째 입력받은 정수를 변수 numA 에 저장, 두번째 입력받은 정수를 numB 에 저장

    • 위와같은 형태로 여러개의 입력을 받을수도 있다.
    • 이때 입력데이터를 구분하는 구분자로는 Tab, Space, Enter등의 공백이 사용된다.

03-문자열 입출력

char str[20];

std::cin>>str;
std::cout<<str<<std::endl;

사용자로부터 입력받은 문자열을 배열 str에 저장하고, 다시 출력

  • 문자열을 입출력할 때는 C언어처럼 배열을 사용한다.
  • 기본형식은 일반적인 입출력형식과 동일하다.

2. 함수 활용

01-함수 오버로딩

💡 동일한 이름의 함수라도, 함수호출 시 전달되는 인자를 통해 함수의 구분이 가능하다.

  • C에서는 동일한 이름을 가지는 함수를 여러개 정의할 수없다.
  • C++에서는 함수의 매개변수의 선언형태가 다르면, 동일한 이름의 함수정의를 허용한다.
    • 매개변수의 개수가 다르다.
    • 매개변수의 자료형이 다르다.
  • 이러한 정의방식을 ‘함수 오버로딩(Function Overloading)’이라고 한다.
  • 반환형태가 다른것은 함수를 구분하는 기준이 될 수 없음에 주의할 것
    → 함수를 호출할 때는 함수이름과 인자만 이용하기 때문에 반환형태를 알 수 없다.

01-함수 오버로딩 활용 예시

#include <iostream>

int func(int);
int func(int, int);

int main(){
    std::cout<<"1번 함수 "<<func(3)<<std::endl;
    std::cout<<"2번 함수 "<<func(3, 3)<<std::endl;
    return 0;
}

//아래의 두 함수는 C에서는 정의할 수 없지만, C++에서는 정의할 수 있다.
int func(int a){
    return a;
}
int func(int a, int b){
    return a+b;
}

02-디폴트 값 : Default Value

  • 함수 호출시 해당 인자가 전달되지 않았을 때, 지정할 매개변수의 값을 디폴트 값이라고한다.
  • 디폴트 값의 특징
    • 디폴트 값을 사용하면, 정의된 매개변수보다 적은수의 인자를 전달할 수 있다.
    • 전달된 인자는 왼쪽의 매개변수부터 대입되며 부족한 인자의 매개변수는 디폴트 값으로 채워진다..
      → 이를 이용하여, 오른쪽 매개변수부터 부분적으로 디폴트 값을 할당할 수도 있다.
  • 디폴트 값 사용방법
    int func(int a=0, int b=0){
    return a+b;
}

//부분적 디폴트 값 사용
int func2(int a, int b=0)
  • 디폴트 값 사용시 오버로딩

    • 아래와 같은 상황에서는 오류가 발생한다.

    • 인자 1개를 전달했을 때, 내가 호출한 함수가 인자 1개의 func인지 아니면 2번째 매개변수는 디폴트 값을 사용하는 인자 2개의 func인지 구분할 수 없기 때문이다.

      int func(int a){
    return a;
}

int func(int a, int b=99){
    return a+b;
}

03-인라인 함수 : Inline

  • C언어의 매크로 함수
    • 컴파일 이전 단계에서 진행되는 선행처리 명령문의 한 종류
    • 매개변수가 존재하는 매크로(#define)의 동작방식을 의미
    • 매크로 함수의 해석방법
      //#define 패턴 변경할유형
#define SQUARE(X) ((X)*(X))

      SQUARE(X) 와 동일한 패턴을 확인하면, 전처리기가 이를 ((X)*(X)) 패턴으로 바꿔준다.

    • 매크로 함수를 잘 사용하기 위해서는 전달인자 하나하나에 괄호를 치고, 전체를 괄호로 다시 묶어줘야한다.
    • 매크로 함수의 특징
      • 장점 : 일반함수에 비해 실행속도가 빠르며 자료형을 신경쓰지 않아도 된다.
      • 단점 : 정의하기 까다로워 복잡한 함수를 표현하는데에는 한계가 있다. (괄호)
  • 인라인함수

    💡 매크로함수의 단점은 제거하고 장점을 유지할 수 있는 기능

    • 전처리기에의해 처리되는 매크로함수와 달리, 인라인함수는 컴파일러에의해 처리된다.
    • 인라인화 : 함수의 body부분이 함수호출문을 완전히 대체하는 경우
    • 인라인함수 정의방법
      inline int SQUARE(int x){
		return x*x;
}
    • 자료형을 사용하기 때문에, 자료형을 신경쓰지 않아도되는 매크로함수의 장점까지 이용하지는 못했다.
      → 템플릿을 이용하면 매크로함수처럼 자료형에 의존적이지 않은 함수를 만들 수 있다.

3. 이름공간 : Namespace

01-이름공간의 개념

💡 특정 공간에 이름을 붙여주기위한 문법적 요소

  • 이름공간의 등장배경
    • 프로그램이 대형화되면서 여러명이 개발에 참여했을때 동일한 이름의 변수, 함수등을 사용하여 발생하는 충돌문제가 야기되기 시작함.
    • 따라서 C++에서는 ‘이름공간'이라는 문법을 정의하여 근복적인 해결책을 제시하고자 한다.
  • 이름공간의 기본원리
    • 각 개발자/회사마다 자신만의 이름공간을 만들고 그 내부에 변수와 함수를 정의한다.
    • 동일한 이름의 변수, 함수를 각기 다른 개발자/회사가 사용하더라도, 서로다른 이름공간에서 정의했기 때문에 충돌이 발생하지 않는다.
  • 범위지정 연산자
    • scope resolution operator
    • 이름공간 안에 정의된 함수를 호출할 때 사용하는 :: 연산자.
    • ex) std::cin
      → 즉, C++ 표준(standard)에서 제공하는 대부분의 기능은 충돌을 방지하기 위해 이름공간 std안에 선언되어있다.

02-이름공간 기반 함수선언 및 정의

  • 함수를 사용할 때, 함수의 선언과 함수의 정의를 구분하는 것이 일반적이다.
    • 함수의 선언 : 헤더파일
    • 함수의 정의 : 소스파일
  • 이름공간에서 함수의 선언과 정의
    • 이름공간 안에는 함수의 선언이 이루어진다.
    • :: 연산자를 이용하여 이름공간 안에서 선언된 함수를 정의할 때 사용한다.
    • 굳이 선언과 정의를 구분하지 않고, 이름공간 안에서 함수의 선언과 정의를 모두 진행해도된다.
  • 함수 선언과 정의의 구분
    #include <iostream>

/*이름공간 생성 및 함수 선언*/
namespace Add {
    int func(int, int);
}
namespace Sub {
		int func(int, int);
}

int main(){
	int a = 7;
	int b = 2;
	//함수 호출
	std::cout<<Add::func(a, b)<<std::endl;  //9
	std::cout<<Sub::func(a, b)<<std::endl;  //5
	return 0;
}

/*이름공간에서 선언된 함수를 정의*/
int Add::func(int a, int b){
    return a+b;
}
int Sub::func(int a, int b){
		return a-b;
}

03-이름공간의 중첩

  • 이름공간은 다른 이름공간 안에 중첩될 수 있다.
  • 이름공간안의 이름공간안의 함수에 접근할 때도 :: 연산자를 이용해 구조적 순차적으로 호출하면 된다.
  • 중첩구조 예시
    #include <iostream>

namespace Outname {
    int num = 0;
    namespace Inname1 {
        int num = 1;
    }
    namespace Inname2 {
        int num = 2;
    }
}

int main(){
		std::cout<<Outname::num<<std::endl;             //0
		std::cout<<Outname::Inname1::num<<std::endl;    //1
    std::cout<<Outname::Inname2::num<<std::endl;    //2
		return 0;
}
  • 중첩이 과도하게 사용되었을 때, 별칭을 이용하면 편리하게 접근할 수 있다.
    • :: 을 이용한 접근과정에 별칭을 붙여준다.
    • 별칭을 선언한 뒤에는, 별칭을 이용하여 이름공간 내부에 접근할 수 있다.
    • 별칭 사용 예시
      #include <iostream>

namespace AAA {
    int num = 0;
    namespace BBB {
        int num = 1;
        namespace CCC {
            int num = 2;
        }
    }
}

int main(){
	std::cout<<AAA::BBB::CCC::num<<std::endl;  //2
    //별칭 사용
    namespace ABC=AAA::BBB::CCC; 
    std::cout<<ABC::num<<std::endl;          //2
    return 0;
}

04-이름공간의 명시 : using

  • using을 이용하여 이름공간 안의 변수,함수를 명시해주면 범위지정연산자를 이용한 접근필요없이 해당 변수,함수의 이름으로 사용이 가능하다.
  • 또는 이름공간 자체를 명시함으로서 해당 이름공간 안에 선언된 모든 변수, 함수에 대해 접근을 생략할 수 있다.
  • 이름공간 명시과정
    • 이름공간안의 항목을 명시
      #include <iostream>
using std::cin;
using std::cout;
using std::endl;

int main(){
		int num;
    cout<<"정수를 입력하세요: ";
    cin>>num;
    cout<<"입력한 정수는 "<<num<<"입니다."<<endl;
    return 0;
}
    • 이름공간 자체를 명시
      #include <iostream>
using namespace std;

int main(){
		int num;
    cout<<"정수를 입력하세요: ";
    cin>>num;
    cout<<"입력한 정수는 "<<num<<"입니다."<<endl;
    return 0;
}

05-범위지정연산자::을 사용한 전역변수 접근

  • 동일한 이름의 지역변수, 전역변수를 사용할 때 지역범위(=함수안)에서 전역변수에 접근하는 방법
  • 전역변수를 사용하려면 변수이름앞에 :: 연산자를 붙여준다.
    ex) ::num

4. bool 자료형

01-참(true)과 거짓(false)

  • C와 C++ 모두 0은 ‘거짓', 0이 아닌 모든 정수는'참’을 의미하는 값으로 사용하고 있다.
  • C++에서는 참과 거짓을 표현하는 키워드 true, false를 정의하고 있다.
    *이전의 C언어 표준에서는 bool 자료형을 지원하지 않았지만, 새로운 표준에서는 bool 자료형을 지원함
  • true와 false를 표현하기 위해서 1바이트 크기의 데이터를 사용한다.
  • true, false 사용예시
    • 소스코드
      #include <iostream>
using namespace std;

int main() {
    cout<<"true와 false의 출력"<<endl;
    cout<<"true: "<<true<<endl;
    cout<<"false: "<<false<<endl;

    cout<<"true와 false의 크기"<<endl;
    cout<<"true: "<<sizeof(true)<<endl;
    cout<<"false: "<<sizeof(false)<<endl;

    return 0;
}
    • 수행결과

02-자료형 bool

  • bool type으로 변수를 생성하여, true/false의 값을 대입할 수 있다.
  • bool또한 기본자료형 중의 하나이기 때문에 다른 기본자료형과 동일한 방식으로 사용할 수 있다.
  • bool 타입 변수 선언예시
    //선언과 대입을 따로
bool IsFirst;      //초기값은 false
IsFirst = true;

//선언과 대입을 동시에
bool IsSecond = false;

5. 참조자와 함수

01-참조자(Reference)의 이해

💡 자신이 참조하는 변수를 대신할 수 있는 또 하나의 이름

  • 참조자는 이미 변수로 선언된 메모리 공간을 가리키는 또다른 이름이다.
  • 참조자를 선언할 때는 & 연산자를 사용한다.
  • **& 연산자의 기능**
    • 이미 선언된 변수 앞에 위치할 때 : 변수의 주소 값을 반환한다.
      ex) int *ptr = &num → 이미 선언된 변수 num의 주소값을 반환(하여 포인터 변수 ptr에 저장)
    • 새로 선언되는 이름;참조자 앞에 위치할 때 : 참조자의 선언을 의미한다.
      ex) int &ref = num → 변수 num에 대한 참조자 ref를 선언
  • 참조자의 선언예시

    • 참조자는 자신이 참조하고자하는 변수와 동일한 자료형으로 선언되어야한다.

    • 참조자의 이름앞에 & 연산자를 붙히고, 참조하고자하는 변수를 대입한다.

      int num = 13;
int &ref = num;

02-참조자의 특징

  • 참조자와 변수의 비교
    • 참조자는 선언이 되고 나면, 변수와 거의 유사한 기능을 가지며 연산결과 또한 동일하다. (변수와 차이가 없다)
    • 그러나 참조자는 변수를 대상으로만 선언될 수 있다는 점에서 변수와 차이를 보인다.
  • 참조자 선언시 유의사항
    • 참조자의 수에는 제한이 없기 때문에, 하나의 변수에 대해 여러 개의 참조자를 선언할 수도 있다. - (1)
      사용예시
        int num = 13;
   int &ref1 = num;
   int &ref2 = num;
   int &ref3 = num;
    • 참조자를 대상으로 참조자를 선언할 수도 있다.
      사용예시 
         int num = 13;
    int &ref1 = num;
    int &ref2 = ref1;
    int &ref3 = ref2;
      → 따라서 위의 소스코드는 하나의 변수에 대해 여러 참조자를 선언한 경우(1)와 동일하다.
    • 참조자는 선언과 동시에 다른 변수/참조자를 참조해야만 한다.
      • 상수값을 대상으로 참조자를 선언할 수는 없다.
        int &ref = 13 (X)
      • 미리 참조자를 선언했다가 후에 참조할 수는 없다.
        'int &ref` (X)
      • 참조자를 선언하며 NULL로 초기화할 수는 없다. (↔  포인터 변수는 가능)
        int &ref = NULL (X)
    • 참조자는 배열의 원소를 하나의 변수로 간주하기 때문에, 참조할 수 있다.
      사용예시
      int arr[3] = {0, 1, 2};
int &arr1 = arr[0];
int &arr2 = arr[1];
int &arr3 = arr[2];
    • 힙공간에 할당된 메모리 공간에도 참조자로 선언할 수 있다. → 포인터 연산없이 힙 영역 접근가능
      int *ptr = new int;  //6-02 참고
int &ref = *ptr;
ref = 20;
cout<<*ptr<<endl;    //출력결과 : 20

03-함수의 호출 방법 : call-by?

  • Call-by-value
    • 값을 인자로 전달하는 함수 호출방식
    • 이 방식으로 선언된 함수는, 함수 외부에 선언되어있는 변수에 대한 접근이 불가능하다.
  • Call-by-reference
    • 주소 값을 인자로 전달하는 함수 호출방식
    • 전달된 주소 값을 활용하여, *연산자를 이용해 해당 주소(=함수 외부에 선언된 변수에 대한 공간)에 직접 접근하여 값을 바꿀 수 있다.

04-참조자와 함수

💡 C++에서는 참조자를 이용하여 call-by-reference 함수호출을 진행할 수 있다.

  • Call-by-reference의 방식
    • 주소 값을 인자로 전달하는 방식
    • ‘참조자'를 인자로 전달하는 방식
  • 참조자를 이용한 호출 예시
    • 소스코드
      #include <iostream>
using namespace std;

void SwapByRef(int &ref1, int &ref2);

int main() {
    int num1 = 11;
    int num2 = 10;

    SwapByRef(num1, num2);
    cout<<"num1: "<<num1<<endl;
    cout<<"num2: "<<num2<<endl;
    return 0;
}

void SwapByRef(int &ref1, int &ref2){
    int temp = ref1;
    ref1 = ref2;
    ref2 = temp;
}
    • 메모리 공간

    • 수행결과

  • 💫  참조자를 이용한 호출 이해하기
    • 함수를 호출하면서 변수를 전달함과 동시에, 매개변수로 지정된 참조자를 전달된 인자로 초기화하면서 생성한다.
    • 이렇게 생성된 참조자는 main함수에 선언된 변수의 공간을 지정하는 또 다른 이름이 된다.
  • 참조자를 이용한 호출의 단점
    • 함수의 호출문(SwapByRef(num1,num2))이 있을 때,
      • 호출문을 보고 그 결과를 예측하기 힘들다.
      • 호출이 발생한 이후에 변수의 값을 예측하기 어렵다.
        → 매개변수가 참조자로 정의되어있다면, 전달된 변수의 값을 변경할 수도 있기 때문이다.
    • const 키워드를 이용하면, 이런 단점을 조금 극복할 수 있다.

05-const 참조자

  • const 키워드를 이용한 함수 호출 단점 극복
    • 매개변수 참조자 앞에 const 키워드를 추가한다.
      ex) VoidSwapByRef(const int &ref1, const int &ref2)
    • 이는 해당 참조자를 이용한 값의 변경을 하지 않겠다는 의도를 명시한다.
    • 만약, 함수 내에서 해당 참조자의 값을 변경하려하면 컴파일에러가 발생한다.
  • const 키워드를 이용한 상수의 참조
    • 상수 참조 방법
      const int &ref = 10;
    • 상수 참조의 내부 원리
      • 10, 13과 같은 리터럴(literal) 상수는 임시값으로, 공간에 할당되지 않아 명령어의 다음 행으로 넘어가면 사라진다.
      • 따라서 const로 상수를 참조할 때 임시변수를 만들어 그 공간에 상수값을 저장하고 참조자가 임시변수공간을 참조하게 내부적으로 처리한다.

06-반환형이 참조형인 함수

참조자를 반환할 때는 다음 세가지 경우로 나뉜다.

  1. 참조형으로 반환하고 참조자에 반환값을 저장하는 경우
  2. 참조형으로 반환하지만 일반변수에 반환값을 저장하는 경우
  3. 참조자를 반환하되, 반환형이 기본자료형인 경우
  • 참조자를 반환하는 경우
    • 참조자를 반환 = 반환형이 참조형(Reference Type)인 경우
      • 반환된 참조값을 새로운 참조자에 저장 : 참조자가 참조하던 변수에 대해 참조의 관계가 1개 더 추가된다.
        int &ref = Func(num);
      • 반환된 참조값을 기본자료형 변수(=참조하던 변수의 자료형)에 저장 : 참조자가 참조하던 변수의 값이 저장된다.
        int num2 = Func(num);
    • 참조자의 값을 반환
      • 참조자를 반환하지만 함수의 반환형이 기본자료형(int, float, …)인 경우
      • 참조자가 참조하던 변수가 저장하고 있던 값을 반환한다.
  • 참조자 반환 case 예시
    • 소스코드
      #include <iostream>
using namespace std;

int PlusOneFunc(int &ref);
int& RefPlusOneFunc(int &ref);

int main() {
    cout<<"=== 참조자에 반환된 참조값을 저장하는 경우 ==="<<endl;
    int num1 = 1;
    int &case1 = RefPlusOneFunc(num1);  //num1=2, &case1=num1
    num1+=1;     //num1=case1=103
    case1+=100;  //num1=case1=103
    cout<<"num: "<<num1<<" case: "<<case1<<endl;

    cout<<"=== 일반변수에 반환된 참조값을 저장하는 경우 ==="<<endl;
    int num2 = 1;
    int case2 = RefPlusOneFunc(num2);  //num2=2, case2=2
    num2+=1;     //num2=3
    case2+=100;  //case2=102
    cout<<"num: "<<num2<<" case: "<<case2<<endl;
    
    cout<<"=== 일반변수에 반환된 값을 저장하는 경우 ==="<<endl;
    int num3 = 1;
    int case3 = PlusOneFunc(num3);    //num3=2, case3=2
    num3+=1;     //num3=3
    case3+=100;  //case3=102
    cout<<"num: "<<num3<<" case: "<<case3<<endl;
    return 0;
}

/*함수 정의*/
int PlusOneFunc(int &ref){
    ref++;
    return ref;
}
int& RefPlusOneFunc(int &ref){
    ref++;
    return ref;
}
    • 수행결과

  • 잘못된 참조의 반환 ; 지역변수를 참조형으로 반환
    • 지역변수를 참조의 형태로 반환하여, 참조자에 저장하면 지역변수에 참조자에 의해 또다른 이름이 붙게 된다.
    • 그러나 함수가 종료되면 정작 참조의 대상이 되는 지역변수는 소멸하게 된다.
    • 따라서 이렇게 구현하면 참조자가 쓰레기값을 참조하게 된다.
    • 컴파일러가 경고메시지만 출력할 뿐, 에러메시지를 출력하지는 않기 때문에 주의하도록하자.

6. new & delete

01-C에서 malloc & free

  • C에서는 힙(HEAP)공간에서의 메모리 할당 및 소멸에 malloc(), free() 함수를 사용한다.
  • malloc & free의 사용예시
    #include <iostream>
#include <string.h>
#include <stdlib.h>
using namespace std;

char* MakeArr(int len);

int main() {
    char* str = MakeArr(20);
    strcpy(str, "Hello World!");
    cout<<str<<endl;
    free(str); 

    return 0;
}

char* MakeArr(int len){
    char* str = (char*)malloc(sizeof(char)*len);  
    return str;
}
  • malloc & free의 단점
    • 사용시 불편한 점
      • 할당하고자 하는 대상의 정보를 무조건 byte 크기단위로 전달해야한다. (malloc의 할당방법은 sizeof(자료형)* 길이이므로)
      • malloc함수의 반환형은 void형 포인터이기 때문에 사용하고자하는 자료형에 맞게 적절한 형변환을 거쳐야한다. ← (char*)
    • 문제점 (객체 생성시)
      • malloc은 오로지 연속된 메모리를 가진 자료형(Plain Old Data;POD)에 대해서만 크기를 정상적으로 할당해줄 수 있다.
      • 그러나, 클래스가 하나의 함수/생성자라도 가지게 되면 POD 타입이 아니기 때문에, malloc으로 객체를 생성하면 제대로 된 할당이 이루어지지 않는다.
        (↔  반면 클래스가 어떤 함수/생성자라도 가지지 않으면 구조체와 동일한 구조이기 때문에 malloc으로 할당할 수 있다.) ⇒ C++에서 제공하는 new, delete함수를 사용하면 이러한 단점들을 해결할 수 있다.

02-new & delete

  • new
    • malloc 함수를 대신하는 키워드
    • 키워드 new의 왼쪽에 할당할 변수, 오른쪽에 할당할 대상의 정보를 명시한다.
    • 할당하고자하는 대상이 배열이면 오른쪽에 자료형 뒤에 배열의 길이를 명시한다.
    • new 사용예시
      • int형 변수의 할당 : int* ptr1 = new int;
      • 길이가 7인 double형 배열의 할당 : double* arr1 = new double[7];
  • delete
    • free 함수를 대신하는 키워드
    • 키워드 delete의 오른쪽에 소멸할 대상을 명시한다.
    • 소멸 대상이 배열이라면 앞에 []를 추가로 명시한다.
    • delete 사용예시
      • 앞서 할당한 int형 변수의 소멸 : delete ptr1;
      • 앞서 할당한 길이가 7인 double형 배열의 할당 : delete []arr1;
  • new & delete의 사용예시
    #include <iostream>
#include <string.h>
using namespace std;

char* MakeArr(int len);

int main() {
    char* str = MakeArr(20);
    strcpy(str, "Hello World!");
    cout<<str<<endl;
    delete []str;

    return 0;
}

char* MakeArr(int len){
    char* str = new char[len];
    return str;
}

7. C++에서 C 추억하기

  • C언어의 라이브러리에 정의된 다양한 유형들의 함수는 C++의 표준 라이브러리에도 포함되어있기에 어렵지 않게 사용할 수 있다.
  • 대부분 C 헤더파일 확장자인 .h를 생략하고 앞에 c를 붙이면 C에 대응하는 C++에서의 헤더파일 이름이 된다.
  • C++의 대표 헤더정보
    • #include <stdio.h> → #include <cstdio>
    • #include <stdlib.h> → #include<cstdlib>
    • #include <math.h> → #include<cmath>
    • #include <string.h> → #include<cstring>
  • C++ 문법을 기반으로 개선된 라이브러리가 잘 구성되어있기 때문에 가급적 C++의 표준헤더를 이용하는 것이 좋다.

본문은 ⟪열혈 C++ 프로그래밍, 윤성우⟫ 도서에 기반하여 정리한 내용입니다.

profile
Vaughan
우주의 아름다움도 다양한 지식을 접하며 스스로의 생각이 짜여나갈 때 불현듯 나를 덮쳐오리라.
다음 포스트

[C++] 클래스

0개의 댓글