클래스(1)

클래스 는 데이터 구조의 확장된 개념입니다 . 데이터 구조 와 마찬가지로 데이터 멤버를 포함할 수 있지만 함수를 멤버로 포함할 수도 있습니다.

객체 는 클래스의 인스턴스화입니다 . 변수의 관점에서 보면 클래스는 유형이고 객체는 변수입니다.

클래스는 다음 구문과 함께 키워드 class또는 키워드 를 사용하여 정의됩니다.struct

class class_name {
  access_specifier_1:
    member1;
  access_specifier_2:
    member2;
  ...
} object_names;

여기서 class_name는 클래스의 유효한 식별자이고 object_names는 이 ​​클래스의 개체에 대한 선택적 이름 목록입니다. 선언의 본문에는 데이터 또는 함수 선언이 될 수 있는 멤버 가 포함될 수 있으며 선택적으로 지정자에 액세스할 수 있습니다 . 클래스는 함수를 포함할 수 있고 액세스 지정 자라는 새로운 항목을 가질 수 있다는 점을 제외하면 일반 데이터 구조

와 동일한 형식을 갖 습니다. 액세스 지정 자는 다음 세 가지 키워드 중 하나입니다. , 또는 . 이러한 지정자는 뒤에 오는 구성원에 대한 액세스 권한을 수정합니다.privatepublicprotected

• private클래스의 구성원은 같은 클래스의 다른 구성원(또는 "친구" )에서만 액세스할 수 있습니다.
• protected멤버는 같은 클래스의 다른 멤버(또는 "친구" )에서 액세스할 수 있지만 파생 클래스의 멤버에서도 액세스할 수 있습니다.
• 마지막으로 public개체가 표시되는 모든 위치에서 멤버에 액세스할 수 있습니다.

기본적으로 class키워드로 선언된 클래스의 모든 멤버는 모든 멤버에 대해 비공개 액세스 권한을 갖습니다. 따라서 다른 액세스 지정자 보다 먼저 선언된 모든 멤버는 자동으로 개인 액세스 권한을 갖습니다. 예를 들어:

class Rectangle {
    int width, height;
  public:
    void set_values (int,int);
    int area (void);
} rect;

Rectangle호출된 클래스(즉, 유형) 와 이 클래스의 개체(즉, 변수)를 라고 선언합니다 rect. 이 클래스에는 4개의 멤버가 포함되어 있습니다. 비공개 액세스 (private가 기본 액세스 수준이기 때문에 ) 유형의 데이터 int멤버 2 width개와 공개 액세스 가 있는 멤버 함수 2개 : 함수 및 , 지금은 그 선언만 포함했습니다. , 그러나 그들의 정의는 아닙니다. 클래스 이름 과 객체 이름 의 차이점에 주목하십시오 . 이전 예에서 는 클래스 이름 (즉, 유형)인 반면 는 유형의 객체입니다.heightset_valuesarea

RectanglerectRectangle. 동일한 관계 int이며 a다음 선언에 있습니다.

int a;

여기서 int는 유형 이름(클래스)이고 a는 변수 이름(객체)입니다. 및

의 선언 후, object의 모든 public 멤버는 object name 과 member name 사이 에 점()을 삽입하기만 하면 일반 함수나 일반 변수처럼 액세스할 수 있습니다 . 이것은 일반 데이터 구조의 멤버에 액세스하는 것과 동일한 구문을 따릅니다. 예를 들어:Rectanglerectrect.

rect.set_values (3,4);
myarea = rect.area();

rect클래스 외부에서 액세스할 수 없는 유일한 멤버 는 width및 height, 비공개 액세스 권한이 있고 동일한 클래스의 다른 멤버 내에서만 참조할 수 있기 때문입니다.

다음은 Rectangle 클래스의 전체 예입니다.

// classes example
#include <iostream>
using namespace std;

class Rectangle {
    int width, height;
  public:
    void set_values (int,int);
    int area() {return width*height;}
};

void Rectangle::set_values (int x, int y) {
  width = x;
  height = y;
}

int main () {
  Rectangle rect;
  rect.set_values (3,4);
  cout << "area: " << rect.area();
  return 0;
}

이 예 에서는 네임스페이스와 관련하여 이전 장에서 본 범위 연산자 ( ::, 두 개의 콜론)를 다시 도입합니다. 여기 set_values에서 클래스 자체 외부의 클래스 멤버를 정의하기 위해 함수 정의에 사용됩니다.

멤버 함수 의 정의 는 매우 단순하기 때문에 area클래스 정의 내에 직접 포함되어 있습니다 . Rectangle반대로, set_values클래스 내에서 프로토타입으로 선언될 뿐이지만 정의는 클래스 외부에 있습니다. 이 외부 정의에서 범위( )의 연산자는 정의되는 함수가 일반 비멤버 함수가 아니라 ::클래스의 멤버임을 지정하는 데 사용됩니다 . 범위 연산자(Rectangle

::) 정의되는 멤버가 속한 클래스를 지정하여 이 함수 정의가 클래스 정의 내에 직접 포함된 것처럼 정확히 동일한 범위 속성을 부여합니다. 예를 들어, 이전 예제의 함수 는 class 의 private 멤버인 set_values변수 width및 에 액세스 할 수 있으므로 this와 같은 클래스의 다른 멤버에서만 액세스할 수 있습니다. 클래스 정의 내에서 멤버 함수를 완전히 정의하는 것과 함수에 선언을 포함하고 나중에 클래스 외부에서 정의하는 것의 유일한 차이점은 첫 번째 경우에 함수가 자동으로 인라인 으로 간주된다는 것입니다.heightRectangle

컴파일러에 의한 멤버 함수인 반면 두 번째에서는 일반(인라인이 아닌) 클래스 멤버 함수입니다. 이로 인해 동작에는 차이가 없지만 가능한 컴파일러 최적화에서만 발생합니다.

멤버 width및 height개인 액세스 권한이 있습니다(다른 항목이 지정되지 않은 경우 키워드로 정의된 클래스의 모든 멤버는 개인 액세스 권한이 있음을 기억하십시오 class). private로 선언하면 클래스 외부에서 접근할 수 없습니다. 객체 내의 해당 멤버에 대한 값을 설정하는 멤버 함수를 이미 정의했기 때문에 이는 의미가 있습니다.set_values. 따라서 프로그램의 나머지 부분은 직접 액세스할 필요가 없습니다. 아마도 이와 같은 간단한 예에서는 이러한 변수에 대한 액세스를 제한하는 것이 얼마나 유용한지 알기 어려울 수 있지만 더 큰 프로젝트에서는 값이 예기치 않은 방식으로 수정될 수 없다는 것이 매우 중요할 수 있습니다(관점에서 예상치 못한 그 물체).

클래스의 가장 중요한 속성은 유형이며, 따라서 클래스의 여러 객체를 선언할 수 있다는 것입니다. 예를 들어, class 의 이전 예제에 따라 우리는 object 외에 object를 Rectangle선언할 수 있었습니다 .rectbrect

// example: one class, two objects
#include <iostream>
using namespace std;

class Rectangle {
    int width, height;
  public:
    void set_values (int,int);
    int area () {return width*height;}
};

void Rectangle::set_values (int x, int y) {
  width = x;
  height = y;
}

int main () {
  Rectangle rect, rectb;
  rect.set_values (3,4);
  rectb.set_values (5,6);
  cout << "rect area: " << rect.area() << endl;
  cout << "rectb area: " << rectb.area() << endl;
  return 0;
}

이 특별한 경우에 클래스(객체의 유형)는 이며 Rectangle, 그 중 두 개의 인스턴스(즉, 객체)가 rect있습니다 rectb. 그들 각각에는 고유한 멤버 변수와 멤버 함수가 있습니다.

에 대한 호출은 에 대한 호출 rect.area()과 동일한 결과를 제공하지 않습니다 rectb.area(). 이는 클래스의 각 개체에 Rectangle고유한 변수가 width있고 height, 어떤 방식으로든 고유한 함수 멤버 가 set_value있고 area개체의 고유한 멤버 변수에서 작동하기 때문입니다.

클래스를 사용하면 객체 지향 패러다임을 사용하여 프로그래밍할 수 있습니다. 데이터와 함수는 모두 객체의 멤버이므로 핸들러 또는 기타 상태 변수를 멤버가 호출되는 객체의 일부이기 때문에 함수에 대한 인수로 전달하고 전달할 필요가 줄어듭니다. rect.area또는 에 대한 호출에 인수가 전달되지 않았습니다 rectb.area. 이러한 멤버 함수는 해당 개체 rect및 의 데이터 멤버를 직접 사용했습니다 rectb.

생성자

area이전 예제에서 멤버 함수 를 호출하기 전에 호출했다면 set_values어떻게 될까요? 멤버 width와 height값이 할당된 적이 없기 때문에 결정되지 않은 결과입니다. 이를 방지하기 위해 클래스에는 해당 클래스 의 새 객체가 생성될 때마다 자동으로 호출되는 생성자

라는 특수 함수가 포함될 수 있으므로 클래스가 멤버 변수를 초기화하거나 스토리지를 할당할 수 있습니다. 이 생성자 함수는 일반 멤버 함수처럼 선언되지만 클래스 이름과 일치하는 이름으로 반환 유형이 없습니다. 아니 . 위 의 클래스는 생성자를 구현하여 쉽게 개선할 수 있습니다.

void

Rectangle

// example: class constructor
#include <iostream>
using namespace std;

class Rectangle {
    int width, height;
  public:
    Rectangle (int,int);
    int area () {return (width*height);}
};

Rectangle::Rectangle (int a, int b) {
  width = a;
  height = b;
}

int main () {
  Rectangle rect (3,4);
  Rectangle rectb (5,6);
  cout << "rect area: " << rect.area() << endl;
  cout << "rectb area: " << rectb.area() << endl;
  return 0;
}

이 예제의 결과는 이전 예제의 결과와 동일합니다. 그러나 이제 클래스 Rectangle에는 멤버 함수가 없고 set_values대신 비슷한 작업을 수행하는 생성자가 있습니다. 즉 , 전달된 인수 로 width및 값을 초기화합니다. 이 클래스의 객체가 생성되는 순간에 이러한 인수가 생성자에 어떻게 전달되는지 확인하십시오.height

Rectangle rect (3,4);
Rectangle rectb (5,6);

생성자는 일반 멤버 함수인 것처럼 명시적으로 호출할 수 없습니다. 해당 클래스의 새 객체가 생성될 때 한 번만 실행됩니다.

생성자 프로토타입 선언(클래스 내)이나 후자의 생성자 정의 모두 반환 값을 갖지 않는 방법에 주목하십시오. not even void: 생성자는 값을 반환하지 않고 단순히 객체를 초기화합니다.

생성자 오버로딩

다른 함수와 마찬가지로 생성자는 다른 매개변수를 사용하는 다른 버전으로 오버로드될 수도 있습니다. 컴파일러는 매개변수가 인수와 일치하는 것을 자동으로 호출합니다.

// overloading class constructors
#include <iostream>
using namespace std;

class Rectangle {
    int width, height;
  public:
    Rectangle ();
    Rectangle (int,int);
    int area (void) {return (width*height);}
};

Rectangle::Rectangle () {
  width = 5;
  height = 5;
}

Rectangle::Rectangle (int a, int b) {
  width = a;
  height = b;
}

int main () {
  Rectangle rect (3,4);
  Rectangle rectb;
  cout << "rect area: " << rect.area() << endl;
  cout << "rectb area: " << rectb.area() << endl;
  return 0;
}

위의 예에서 두 개의 클래스 객체 Rectangle가 생성되었습니다: rect및 rectb. rect이전 예제와 같이 두 개의 인수로 구성됩니다.

그러나 이 예제는 또한 특별한 종류의 생성자를 소개합니다: 기본 생성자 . 기본 생성자 는 매개변수를 사용하지 않는 생성자이며 객체가 선언되었지만 인수로 초기화되지 않을 때 호출되기 때문에 특별합니다. 위의 예에서 기본 생성자 는 에 대해 호출됩니다 rectb. 가 빈 괄호 세트로 구성되지 않는 방법에 유의하십시오 rectb. 사실, 기본 생성자를 호출하는 데 빈 괄호를 사용할 수 없습니다.

Rectangle rectb;   // ok, default constructor called
Rectangle rectc(); // oops, default constructor NOT called

이는 빈 괄호 세트가 rectc객체 선언 대신 함수 선언을 만들기 때문입니다. 인수를 사용하지 않고 type 값을 반환하는 함수가 될 것입니다 Rectangle.

Uniform initialization

위와 같이 인수를 괄호로 묶어 생성자를 호출하는 방식을 함수형 이라고 합니다 . 그러나 생성자는 다른 구문으로도 호출할 수 있습니다.

첫째, 단일 매개변수가 있는 생성자는 변수 초기화 구문(등호 뒤에 인수가 옴)을 사용하여 호출할 수 있습니다. 더 최근에는 C++에서 균일 초기화

class_name object_name = initialization_value;

를 사용하여 생성자를 호출할 수 있는 가능성을 도입했습니다. , 본질적으로 기능 형식과 동일하지만 괄호( ) 대신 중괄호( ) 사용 : 선택적으로 이 마지막 구문은 중괄호 앞에 등호를 포함할 수 있습니다. 다음은 생성자가 단일 매개변수를 사용하는 클래스의 객체를 생성하는 네 가지 방법이 있는 예입니다.{}()

class_name object_name { value, value, value, ... }

// classes and uniform initialization
#include <iostream>
using namespace std;

class Circle {
    double radius;
  public:
    Circle(double r) { radius = r; }
    double circum() {return 2*radius*3.14159265;}
};

int main () {
  Circle foo (10.0);   // functional form
  Circle bar = 20.0;   // assignment init.
  Circle baz {30.0};   // uniform init.
  Circle qux = {40.0}; // POD-like

  cout << "foo's circumference: " << foo.circum() << '\n';
  return 0;
}

함수형에 대한 균일 초기화의 장점은 괄호와 달리 중괄호가 함수 선언과 혼동될 수 없으므로 기본 생성자를 명시적으로 호출하는 데 사용할 수 있다는 것입니다.

Rectangle rectb;   // default constructor called
Rectangle rectc(); // function declaration (default constructor NOT called)
Rectangle rectd{}; // default constructor called 

생성자를 호출하는 구문의 선택은 주로 스타일의 문제입니다. 대부분의 기존 코드는 현재 기능적 형식을 사용하고 일부 새로운 스타일 가이드에서는 유형으로 선호하는 잠재적인 함정이 있음에도 불구하고 다른 것보다 균일한 초기화를 선택하도록 제안합니다

생성자의 멤버 초기화

생성자를 사용하여 다른 멤버를 초기화하는 경우 본문의 명령문에 의존하지 않고 이러한 다른 멤버를 직접 초기화할 수 있습니다. 이것은 생성자의 본문 앞에 콜론( :)과 클래스 멤버의 초기화 목록을 삽입하여 수행됩니다. 예를 들어 다음 선언이 있는 클래스를 고려하십시오.

class Rectangle {
    int width,height;
  public:
    Rectangle(int,int);
    int area() {return width*height;}
};

이 클래스의 생성자는 평소와 같이 다음과 같이 정의할 수 있습니다.

Rectangle::Rectangle (int x, int y) { width=x; height=y; }

그러나 멤버 초기화 를 사용하여 다음과 같이 정의할 수도 있습니다 .

Rectangle::Rectangle (int x, int y) : width(x) { height=y; }

또는:

Rectangle::Rectangle (int x, int y) : width(x), height(y) { }

이 마지막 경우에 생성자는 멤버를 초기화하는 것 외에는 아무 것도 하지 않으므로 빈 함수 본문이 있습니다.

기본 유형의 멤버의 경우 기본적으로 초기화되지 않기 때문에 생성자 위의 방법 중 어떤 것이 정의되는지 차이가 ​​없지만 멤버 객체(유형이 클래스인 객체)의 경우 콜론 뒤에 초기화되지 않으면 기본적으로 구성되어 있습니다.

클래스의 모든 멤버를 기본값으로 구성하는 것이 편리할 수도 있고 항상 그렇지 않을 수도 있습니다. 어떤 경우에는 낭비이지만(구성자에서 멤버가 다시 초기화되는 경우), 다른 경우에는 기본 구성이 불가능합니다. (클래스에 기본 생성자가 없을 때). 이 경우 멤버 초기화 목록에서 멤버를 초기화합니다. 예를 들어:

// member initialization
#include <iostream>
using namespace std;

class Circle {
    double radius;
  public:
    Circle(double r) : radius(r) { }
    double area() {return radius*radius*3.14159265;}
};

class Cylinder {
    Circle base;
    double height;
  public:
    Cylinder(double r, double h) : base (r), height(h) {}
    double volume() {return base.area() * height;}
};

int main () {
  Cylinder foo (10,20);

  cout << "foo's volume: " << foo.volume() << '\n';
  return 0;
}

이 예에서 class 에는 유형이 다른 클래스( 의 유형은 ) Cylinder인 멤버 개체가 있습니다. 클래스의 객체는 매개변수로만 생성할 수 있기 때문에 의 생성자는 의 생성자를 호출해야 하며 이를 수행하는 유일한 방법은 멤버 이니셜라이저 목록 에 있습니다. 이러한 초기화는 괄호 대신 중괄호를 사용하여 균일한 초기화 구문을 사용할 수도 있습니다 .baseCircleCircleCylinderbase

Cylinder::Cylinder (double r, double h) : base{r}, height{h} { }

클래스에 대한 포인터

객체는 포인터로 가리킬 수도 있습니다. 일단 선언되면 클래스는 유효한 유형이 되므로 포인터가 가리키는 유형으로 사용할 수 있습니다. 예를 들어:

Rectangle * prect;

클래스의 개체에 대한 포인터입니다 Rectangle.

일반 데이터 구조와 유사하게 화살표 연산자( )를 사용하여 포인터에서 개체의 멤버에 직접 액세스할 수 있습니다 ->. 다음은 몇 가지 가능한 조합의 예입니다.

// pointer to classes example
#include <iostream>
using namespace std;

class Rectangle {
  int width, height;
public:
  Rectangle(int x, int y) : width(x), height(y) {}
  int area(void) { return width * height; }
};


int main() {
  Rectangle obj (3, 4);
  Rectangle * foo, * bar, * baz;
  foo = &obj;
  bar = new Rectangle (5, 6);
  baz = new Rectangle[2] { {2,5}, {3,6} };
  cout << "obj's area: " << obj.area() << '\n';
  cout << "*foo's area: " << foo->area() << '\n';
  cout << "*bar's area: " << bar->area() << '\n';
  cout << "baz[0]'s area:" << baz[0].area() << '\n';
  cout << "baz[1]'s area:" << baz[1].area() << '\n';       
  delete bar;
  delete[] baz;
  return 0;
}	

이 예제에서는 여러 연산자를 사용하여 개체와 포인터(연산자 *, &, ., ->, [])를 처리합니다. 다음과 같이 해석할 수 있습니다.

표현로 읽을 수 있습니다

 

expression	can be read as
*x	pointed to by x
&x	address of x
x.y	member y of object x
x->y	member y of object pointed to by x
(*x).y	member y of object pointed to by x (equivalent to the previous one)
x[0]	first object pointed to by x
x[1]	second object pointed to by x
x[n]	(n+1)th object pointed to by x

이러한 표현의 대부분은 이전 장에서 소개되었습니다. 특히 배열에 대한 장에서는 오프셋 연산자( [])를 소개했고 일반 데이터 구조에 대해서는 화살표 연산자( ->)를 소개했습니다.

구조체 및 공용체로 정의된 클래스

클래스는 키워드 class뿐만 아니라 키워드 struct및 로도 정의할 수 있습니다 union.

일반적으로 일반 데이터 구조를 선언하는 데 사용되는 키워드 struct는 키워드와 동일한 구문으로 멤버 함수가 있는 클래스를 선언하는 데 사용할 수도 있습니다 class. 둘 사이의 유일한 차이점은 키워드로 선언된 클래스의 멤버는 기본적으로 액세스 권한 struct이 public있는 반면 키워드로 선언된 클래스의 멤버는 기본적으로 액세스 권한이 class있다는 것 private입니다. 다른 모든 목적의 경우 두 키워드는 이 컨텍스트에서 동일합니다.

반대로 공용체struct 의 개념은 and 로 선언된 클래스의 개념과 다릅니다.class, 공용체는 한 번에 하나의 데이터 멤버만 저장하지만 그럼에도 불구하고 클래스이기도 하므로 멤버 함수도 보유할 수 있습니다. 공용체 클래스의 기본 액세스는 입니다 public.