c++ 기본 문법 정리

http://hyunssssss.tistory.com/33

 

[ c++ 기본 문법 정리1 ]

●c++은 객체지향 프로그래밍 언어이다

 

●확장자는 '.cpp' 사용

 

●c++ 기본구조
ex)
#include <iostream>
int main(){
  std::cout<<"hello world\n";
  return 0;
}

 

●구조체 - 여러개의 변수를 하나로 묶은것
   클래스 - 변수와 함수를 하나로 묶은것

 

●오브젝트(object)
-클래스는 변수의 자료형과 같은 것으로 그 자체로는 값을 저장할수 없다. 오브젝트는 클래스를 바탕으로 값을 저장할 수 있는 실체이자

 

●클래스의 정의
ex)
class Aaa{
   public:                           //접근 제한자 뒤에 ':(콜론)''붙임, 접근제한자 생략하면 모든 멤버는 private가 된다
      void Add(int a);            //클래스 외부에 함수 정의
      int Del(int b){               //클래스 내부에 함수 정의
          return b;
      }
   int x, y;
};                                    //클래스 끝에 ';(세미콜론)' 기술

void Aaa::Add(int a){           //'클래스명::함수명'을 써서 어느 클래스의 멤버함수인지 구분
   total+=a;
}

 

●오브젝트(객체)의 생성
 - '클래스명 오브젝트명;'     //변수 선언과 유사하다

 

●같은 오브젝트 내의 멤버함수 호출 - 그냥 함수명만 기술하면 된다

●다른 오브젝트의 멤버함수를 호출 - '.(피리어드)'를 사용한다
- '오브젝트명.함수명();'

 

●생성자(constructor) - 오브젝트를 생성할때 자동적으로 호출되는 특수한 함수. 생성자는 public로 해야한다.
ex)
class Aaa{
   public:
      Aaa();                  //생성자는 반환값이 없고, void형 지정도 하지 않는다.
};
Aaa:Aaa(){
   total=0;
}
int main(){
   Aaa a;
}

 

●소멸자(destructor)
- 오브젝트가 소멸할때 호출됨. public로 해야한다. 프로그래머가 소멸자를 정의하지 않으면 디폴트로 준비도니다. 클래스 안에 하나만 정의할 수 있다. 소멸자의 선언은 '~'를 기술하여 쓴다.
ex)
class Aaa{
   public:
      Aaa();
     ~Aaa();
};
Aaa::~Aaa(){
   printf("임수 완료\n");
}

 

●
c언어에서는 블록안의 선두에서 변수를 선언해야 했지만

c++에서는 변수를 사용하기 전이라면 어디에서나 선언할 수 있다.

될수 있으면 변수선언은 사용하기 직전에 하는게 좋다

 

●c++에서는 for문안에 카운터를 선언할 수 있다.
ex)
for( int i=1; i<5; i++ ) 

 

 

[ c++ 기본 문법 정리2 ]

 ●c언어에서는 배열사이즈를 정의할 때 상수선언을 #define으로 했지만, c++에서는 const로 할 수 있다.
가능한 const를 사용하는게 좋다
ex)
c언어
 #define B 10             
int main(){
   int b[B];
}

c++
 int main(){
    const int B;
    int b[B];
}

 

●함수의 디폴트 인수 설정 - 거의 매번 같은 값을 가지지만 가끔씩 변경해야할 경우에 사용하면 편리
ex)
프로토 타입에서 설정
double A( int a=1, double b=3.1);

함수 정의에서 설정
 double A( int a=1, int b=3.1){
  ~~
}

 

●디폴트 인수 설정된 함수 호출
ex)
double area;
area=A();                //아무 것도 없으면 디폴트인수로 된다
area=A(10);             //첫번째 인수부터 채워진다. 첫번째 인수는 10, 두번째 인수는 디폴트 인수로 된다
area=A(10, 3.11);     //첫번째 두번째 인수는 10, 두번째 인수는 3.11이다

 

●디폴트 인수 설정시 주의점
- 디폴트 인수는 마지막 인수부터 차례로 설정해야함. 첫번째 인수에만 디폴트 설정하면 컴파일 에러 발생
ex)
double A(int a, int b=1);     //(O)
double B(int a=1, int b);     //(X), 컴파일 에러발생

 

●오버로딩
- 인수의 형이나 개수가 다르고 동일한 이름의 함수를 여러개 정의한것.
단, 반환형의 형만 다른 함수는 오버로딩할 수 없다.

 

●표준 출력 스트림 - std::cout
ex)
#include <iostream>
int a;
std::cout<<"Hello"<<"World"<<a<<std:endl;

 

●표준 입력 스트립 - std::cin
ex)
#include <iostream>
int a;
std::cin>>a;

 

●스코프 연산자('::')
- 로컬 변수와 클로벌 변수의 이름이 같을 경우 함수안에서는 로컬변수가 우선하지만
스코프연산자를 사용하면 글로벌 변수를 우선시킬 수 있다.
스코프연산자 앞에 클래스명을 붙이면 오브젝트 내의 멤버를 우선시킬 수 있다.
ex)
::a
A::a

 

●namespace(이름공간)
- namespace 내의 변수와 함수를 이용하기 위해서는 ' namespace명::함수명이나변수명이나클래스명'을 기술한다.
매번 'namespace::'라고 기술하는 것이 번거롭기 때문에 'using namespace 이름공간명;"을 기술하면 편하다

●namespace std
- std::cout나 std::cin은 std라는 이름공간에 있기 때문에 'using namespace std;'를 기술하면 그냥 cout, cin써도 된다.

 

●인라인 함수
- 함수에 'inline' 붙이면 컴파일러는 호출하는 곳으로 함수의 정의를 복사해서 넣는다. 인수를 복사하거나 함수를 호출하는 처리가 생략되므로 실행속가 빨라진다. 그러나 코드가 중복되는 만큼 프로그램의 사이즈는 커지기 때문에 모조건 인라인 함수가 좋은 것은 아니다. 주로 처리 내용이 작은 함수나 호출 횟수가 많은 함수를 인라인으로 하면 좋다.
ex)
inline int A(int a, int b){
   return a+b;
} 

[ c++ 기본 문법 정리3 ]

 ●new 연산자 - 오브젝트를 동적으로 생성할 때 사용
ex)
A *a;
a=new A;

A *a=new A;

 

●delete 연산자 - new연산자로 확보한 메모리는 delete연산자로 해체해야한다.
ex)
A *a=new A;
delete a;

 

●new, delete를 이용해서 int형 등의 메모리 확보, 해체
ex)
int *a=new int;
delete a;

//malloc,free를 쓸경우
int *a=(itn *)malloc(sizeof(int));
free(a);

●malloc()함수보다 new연산자를 사용하는 것이 간단하기 때문에 권장

 

●new연산자를 이용한 배열용 메모리 확보, 해체
ex)
a=new[10];       //[]안에 숫자 적어야 함
delete []a;        //delete뒤에 '[]'기술해야 함

 

●참조
- 변수에 별명을 붙이는것. c언어의 포인터와 달리 사용할때 '*' 안 써도 된다. 한쪽을 변경하면 다른 한쪽도 동일하게 변경된다. '&'사용.
ex)
int a;
int &b=a;    //b가 별명이다.
b=10;
cout<<b<<endl;    //b는10 이다
cout<<a<<endl;    //a는10 이다

 

●함수의 인수로 참조를 사용하기 - 가인수를 참조하면 함수내부에서 실인수를 변경할 수 있다.
ex)
double A(double &a, double &b){
return a+b;
}
double x=1.1 , y=2.2;
double ans=A(x, y);

 

●인수를 const 형식의 참조로 만들
- 실인수의 값이 변경되면 곤란한 경우 가인수에 onst를 붙인다. 구조체 같은 큰 데이터를 함수에 전달할 때 const형식으로 하면 효과적이다.
ex)
void A(const double &a)
{
~~~
}

 

●상속 - 이미 존재하는 클래스를 바탕으로 새로운 크랠스를 만드는 것.
클래스명 뒤에 ' :접근제한자 부모클래스명 '을 기술
ex)
class Food{
~~
};
class Fruit :public Food {
~~
};

 

●자식 클래스의 오브젝트는 부모클래스의 오브젝트에 대입 가능
   부모 클래스의 오브젝트는 자식클래스의 오브젝트에 대입 불가능

 

●자식 클래스에서 부모 클래스의 멤버함수를 재정의
- 함수명, 인수, 반환값은 동일해야함. 재정의 한쪽의 함수가 호출됨
ex)
class Food{
   public:
      void setP(int a){
      price=a;
      }
   private:
      int price;
};
class Fruit :public Food{
   public:
      void setP(int a){
      Food::setP(a-20);            //자식클래스에서 부모클래스에 있는 같은 이름의 함수를 호출하기 위해서는
      }                                   //스코프연산자(::)를 사용
};

 

●가상 함수를 재정의 한 것을 오버라이딩이라 한다.

 

●순수 가상 함수
- 기본 클래스에서 내용을 정의하지 않은 가상함수. 순수가상함수를 포함하는 클래스의 오브젝트는 생성X. 함수 선언 제일 앞에 'virtual'을 쓰고 제일 뒤에 '=0'을 붙인다.
ex)
class Food{
   public:
      virtual void setP(int a)=0;
}; 

[ c++ 기본 문법 정리4 ]

 ●템플릿 함수
- 인수나 반환값의 형을 모호한 상태로 정의하는 함수. 템플릿 함수의 기능을 사용하면, 복수의 형에 대응하느 함수를 만들 수 있다. 컴파일러는 템플릿 함수를 호출하는 부분을 발견하면, 이것들을 구체적인 함수로 만든다.
ex)
template<class T>
T Aaa(T a, T b){               //템플릿 인수(T) 부분에 int형이나 double등 자료형이 치환된다.
   T buf;
   ~~
}
int a=100, b=200, c;
c=Aaa(a, b);               //템플릿 인수가 int로 치환

●템플릿 함수의 이용
- 템플릿 함수를 이용하면 내용은 거의 동일하지만 형이 다른 함수를 하나로 만들 수 있다.

 

●템플릿 클래스
- 사용하는 형을 모호한 상태로 정의하는 클래스. 템플릿 클래스 기느을 사용하면 복수의 형에 대응하는 클래스를 만들 수 있다.
ex)
template<class T>
class Aaa{
   public:
      ~~
      T Add(){
          return a+b;
      }
      T a, b, c, d;
};

 

●템플릿 클래스의 오브젝트를 생성할 꼉우, 다음과 같이 사용할 형을 지정.
ex)
Aaa<int> aa;
Aaa<double> aa;

 

●템플릿 인수가 2개 이상 있을 경우, 다음과 같이 형을 복수로 지정
template<class T1, class T2>
class Aaa{
~~
};

Aaa<int, char> aa;

 

●표준 템플릿 라이브러리(STL - Standard Template Library)
- 템플릿 클래스를 사용하는 표준 라이브러리