클래스(2)

연산자 오버로딩

클래스는 기본적으로 C++ 코드에서 사용할 새 유형을 정의합니다. 그리고 C++의 유형은 구성 및 할당을 통해 코드와 상호 작용할 뿐만 아닙니다. 그들은 또한 연산자를 통해 상호 작용합니다. 예를 들어 기본 유형에 대해 다음 작업을 수행합니다.

int a, b, c;
a = b + c;

여기에서 기본형( )의 다른 변수는 int더하기 연산자를 적용한 다음 할당 연산자를 적용합니다. 기본 산술 유형의 경우 이러한 연산의 의미는 일반적으로 명확하고 모호하지 않지만 특정 클래스 유형에서는 그렇지 않을 수 있습니다. 예를 들어:

struct myclass {
  string product;
  float price;
} a, b, c;
a = b + c;

b여기서 덧셈 연산의 결과가 무엇을 하고 무엇을 하는지는 분명 c하지 않습니다. 사실, 이 코드만으로는 유형 myclass에 추가 동작이 정의되어 있지 않기 때문에 컴파일 오류가 발생합니다. 그러나 C++에서는 대부분의 연산자가 클래스를 포함하여 거의 모든 유형에 대해 동작을 정의할 수 있도록 오버로드될 수 있습니다. 다음은 오버로드될 수 있는 모든 연산자 목록입니다.

+    -    *    /    =    <    >    +=   -=   *=   /=   <<   >>
<<=  >>=  ==   !=   <=   >=   ++   --   %    &    ^    !    |
~    &=   ^=   |=   &&   ||   %=   []   ()   ,    ->*  ->   new 
delete    new[]     delete[]

연산자는 operator특수 이름을 가진 일반 함수인 함수를 통해 오버로드됩니다. 해당 이름은 operator키워드로 시작하고 그 뒤에 오버로드된 연산자 기호 가 옵니다 . 구문은 다음과 같습니다.

 

type operator sign (parameters) { /*... body ...*/ }
예를 들어, 데카르트 벡터 는 두 좌표 세트 x및 y입니다. 두 데카르트 벡터x 의 덧셈 연산은 두 좌표를 함께 더하고 두 좌표를 함께 더하는 것으로 정의됩니다 y. 예를 들어, 데카르트 벡터 (3,1) 와 (1,2)함께 추가하면 (3+1,1+2) = (4,3). 이것은 다음 코드를 사용하여 C++로 구현할 수 있습니다.

// overloading operators example
#include <iostream>
using namespace std;

class CVector {
  public:
    int x,y;
    CVector () {};
    CVector (int a,int b) : x(a), y(b) {}
    CVector operator + (const CVector&);
};

CVector CVector::operator+ (const CVector& param) {
  CVector temp;
  temp.x = x + param.x;
  temp.y = y + param.y;
  return temp;
}

int main () {
  CVector foo (3,1);
  CVector bar (1,2);
  CVector result;
  result = foo + bar;
  cout << result.x << ',' << result.y << '\n';
  return 0;
}

의 너무 많은 모양에 대해 혼란스럽다면 CVector그들 중 일부는 클래스 이름(즉, 유형) 을 참조 CVector하고 일부는 해당 이름을 가진 함수(즉, 클래스와 동일한 이름을 가져야 하는 생성자)를 참조한다는 점을 고려하십시오. 예를 들어:

CVector (int, int) : x(a), y(b) {}  // function name CVector (constructor)
CVector operator+ (const CVector&); // function that returns a CVector

operator+클래스 의 기능 은 해당 유형에 대한 CVector더하기 연산자( )를 오버로드합니다 . +일단 선언되면 이 함수는 연산자를 사용하여 암시적으로 호출하거나 함수 이름을 명시적으로 사용하여 호출할 수 있습니다.

c = a + b;
c = a.operator+ (b);

두 표현 모두 동일합니다.

연산자 오버로드는 모든 동작을 가질 수 있는 일반 함수입니다. 실제로 그 오버로드에 의해 수행되는 연산이 연산자의 수학적 또는 일반적인 의미와 관련이 있어야 한다는 요구 사항은 없지만 강력하게 권장됩니다. 예를 들어 operator+실제로 빼기 위해 오버로드하거나 operator==개체를 0으로 채우기 위해 오버로드하는 클래스는 이러한 클래스를 사용하는 것이 어려울 수 있지만 완벽하게 유효합니다.

다음과 같은 작업의 멤버 함수 오버로드에 필요한 매개변수operator+당연히 연산자의 오른쪽에 있는 피연산자입니다. 이것은 모든 이항 연산자(왼쪽에 피연산자가 있고 오른쪽에 하나의 피연산자가 있는 연산자)에 공통입니다. 그러나 운영자는 다양한 형태로 나타날 수 있습니다. 여기에 오버로드될 수 있는 다른 연산자 각각에 필요한 매개변수 요약이 있는 테이블이 있습니다( @각 경우에 연산자로 교체하십시오).

표현운영자멤버 함수비회원 함수

expression	operator	member function	non member function
@a	+ - * & ! ~ ++ --	A::operator@()	operator@(A)
a@	++ --	A::operator@(int)	operator@(A,int)
a@b	+ - * / % ^ & | < > == != <= >= << >> && || ,	A::operator@(B)	operator@(A,B)
a@b	= += -= *= /= %= ^= &= |= <<= >>= []	A::operator@(B)	-
a(b,c...)	()	A::operator()(B,C...)	-
a->b	->	A::operator->()	-
(TYPE) a	TYPE	A::operator TYPE()	-

여기서 a는 class 의 객체 A이고 는 class 의 객체 이고 는 bclass 의 객체입니다 . 모든 유형입니다(연산자는 type 으로의 변환을 오버로드함 ). 일부 연산자는 멤버 함수 또는 비멤버 함수의 두 가지 형식으로 오버로드될 수 있습니다. 첫 번째 경우는 에 대한 위의 예에서 사용되었습니다 . 그러나 일부 연산자는 비멤버 함수로 오버로드될 수도 있습니다. 이 경우 연산자 함수는 적절한 클래스의 객체를 첫 번째 인수로 취합니다. 예를 들어:BcCTYPETYPE

// non-member operator overloads
#include <iostream>
using namespace std;

class CVector {
  public:
    int x,y;
    CVector () {}
    CVector (int a, int b) : x(a), y(b) {}
};


CVector operator+ (const CVector& lhs, const CVector& rhs) {
  CVector temp;
  temp.x = lhs.x + rhs.x;
  temp.y = lhs.y + rhs.y;
  return temp;
}

int main () {
  CVector foo (3,1);
  CVector bar (1,2);
  CVector result;
  result = foo + bar;
  cout << result.x << ',' << result.y << '\n';
  return 0;
}

The keyword this

키워드 this는 멤버 함수가 실행 중인 개체에 대한 포인터를 나타냅니다. 클래스의 멤버 함수 내에서 개체 자체를 참조하는 데 사용됩니다.

그 용도 중 하나는 멤버 함수에 전달된 매개 변수가 개체 자체인지 확인하는 것입니다. 예를 들어:

// example on this
#include <iostream>
using namespace std;

class Dummy {
  public:
    bool isitme (Dummy& param);
};

bool Dummy::isitme (Dummy& param)
{
  if (&param == this) return true;
  else return false;
}

int main () {
  Dummy a;
  Dummy* b = &a;
  if ( b->isitme(a) )
    cout << "yes, &a is b\n";
  return 0;
}

operator=참조로 개체를 반환하는 멤버 함수 에서도 자주 사용됩니다 . 이전에 본 데카르트 벡터 에 대한 예제를 따르면 해당 operator=기능은 다음과 같이 정의될 수 있습니다.

CVector& CVector::operator= (const CVector& param)
{
  x=param.x;
  y=param.y;
  return *this;
}

사실, 이 함수는 컴파일러가 이 클래스에 대해 암시적으로 생성하는 코드와 매우 유사합니다 operator=.

 

정적 멤버

클래스에는 데이터 또는 함수의 정적 멤버가 포함될 수 있습니다.

클래스의 정적 데이터 멤버는 동일한 값을 공유하는 동일한 클래스의 모든 개체에 대해 하나의 공통 변수만 있기 때문에 "클래스 변수"라고도 합니다. 다른 사람에게 수업.

예를 들어, 다음 예제와 같이 현재 할당된 해당 클래스의 개체 수가 포함된 카운터를 포함할 수 있는 클래스 내의 변수에 사용할 수 있습니다.

// static members in classes
#include <iostream>
using namespace std;

class Dummy {
  public:
    static int n;
    Dummy () { n++; };
};

int Dummy::n=0;

int main () {
  Dummy a;
  Dummy b[5];
  cout << a.n << '\n';
  Dummy * c = new Dummy;
  cout << Dummy::n << '\n';
  delete c;
  return 0;
}

실제로 정적 멤버는 비멤버 변수와 동일한 속성을 갖지만 클래스 범위를 즐깁니다. 이러한 이유로 여러 번 선언되는 것을 피하기 위해 클래스에서 직접 초기화할 수 없지만 외부에서 초기화해야 합니다. 이전 예에서와 같이:

int Dummy::n=0;

동일한 클래스의 모든 객체에 대한 공통 변수 값이기 때문에 해당 클래스의 모든 객체의 멤버로 참조하거나 클래스 이름으로 직접 참조할 수도 있습니다(물론 이는 정적 멤버에만 유효함).

cout << a.n;
cout << Dummy::n;

위의 두 호출은 동일한 변수, 즉 이 클래스의 모든 객체가 공유하는 n클래스 내의 정적 변수를 참조합니다 . 다시 말하지만, 이는 비멤버 변수와 같지만 클래스(또는 개체)의 멤버처럼 액세스해야 하는 이름이 있습니다. 클래스는 정적 멤버 함수를 가질 수도 있습니다. 이들은 동일하게 나타냅니다. 해당 클래스의 모든 객체에 공통인 클래스의 멤버로, 비멤버 함수처럼 정확하게 작동하지만 클래스의 멤버처럼 액세스됩니다. 비멤버 함수와 같기 때문에 클래스의 비정적 멤버에 액세스할 수 없습니다(멤버 변수도 멤버 함수도 아님). 둘 다 키워드를 사용할 수 없습니다 .Dummy

Const 멤버 함수

클래스의 객체가 객체로 규정되는 경우 const:

const MyClass myobject;

클래스 외부에서 데이터 멤버에 대한 액세스 는 모든 데이터 멤버가 const클래스 외부에서 액세스하는 사용자를 위한 것처럼 읽기 전용으로 제한됩니다. 그러나 생성자는 여전히 호출되며 이러한 데이터 멤버를 초기화하고 수정할 수 있습니다.

// constructor on const object
#include <iostream>
using namespace std;

class MyClass {
  public:
    int x;
    MyClass(int val) : x(val) {}
    int get() {return x;}
};

int main() {
  const MyClass foo(10);
// foo.x = 20;            // not valid: x cannot be modified
  cout << foo.x << '\n';  // ok: data member x can be read
  return 0;
}

객체 의 멤버 함수 는 자신이 멤버 const로 지정된 경우에만 호출할 수 있습니다 . const위의 예에서 get로 지정되지 않은 멤버 const는 에서 호출할 수 없습니다 foo. 멤버가 멤버임을 지정하기 const위해 const키워드는 매개변수에 대한 닫는 괄호 뒤에 함수 프로토타입을 따라야 합니다.

int get() const {return x;}

const멤버 함수에서 반환된 형식을 한정하는 데 사용할 수 있습니다 . 이것은 const멤버를 로 지정하는 것과 동일하지 않습니다 const. 둘 다 독립적이며 함수 프로토타입의 다른 위치에 있습니다.

int get() const {return x;}        // const member function
const int& get() {return x;}       // member function returning a const&
const int& get() const {return x;} // const member function returning a const&

로 지정된 멤버 함수 const는 비정적 데이터 멤버를 수정하거나 다른 비 const멤버 함수를 호출할 수 없습니다. 본질적으로 const구성원은 개체의 상태를 수정해서는 안 됩니다.

const객체는 로 표시된 멤버 함수에만 액세스하도록 제한 const되지만 비 const객체는 제한되지 않으므로 const비 const멤버 함수와 모두에 액세스할 수 있습니다.

어쨌든 개체를 거의 선언하지 않을 것이며 const따라서 개체를 수정하지 않는 모든 멤버를 const로 표시하는 것은 노력할 가치가 없다고 생각할 수 있지만 const 개체는 실제로 매우 일반적입니다. 클래스를 매개변수로 사용하는 대부분의 함수는 실제로 참조로 클래스를 사용하므로 이러한 함수는 해당 멤버 const에만 액세스할 수 있습니다 .const

// const objects
#include <iostream>
using namespace std;

class MyClass {
    int x;
  public:
    MyClass(int val) : x(val) {}
    const int& get() const {return x;}
};

void print (const MyClass& arg) {
  cout << arg.get() << '\n';
}

int main() {
  MyClass foo (10);
  print(foo);

  return 0;
}

이 예에서 가 멤버 get로 지정되지 않은 경우 객체는 멤버 함수 에만 액세스할 수 있으므로 함수 에서 에 대한 호출 이 불가능 합니다. 멤버 함수는 constness에 따라 오버로드될 수 있습니다. 즉, 하나는 is 이고 다른 하나는 그렇지 않다는 점을 제외하고 클래스는 동일한 서명을 가진 두 개의 멤버 함수를 가질 수 있습니다. 이 경우 버전은 객체 자체가 const이고 non - version은 객체 자체가 non-일 때 호출됩니다 .constarg.get()printconstconst

// overloading members on constness
#include <iostream>
using namespace std;

class MyClass {
    int x;
  public:
    MyClass(int val) : x(val) {}
    const int& get() const {return x;}
    int& get() {return x;}
};

int main() {
  MyClass foo (10);
  const MyClass bar (20);
  foo.get() = 15;         // ok: get() returns int&
// bar.get() = 25;        // not valid: get() returns const int&
  cout << foo.get() << '\n';
  cout << bar.get() << '\n';

  return 0;
}

클래스 템플릿

함수 템플릿을 생성할 수 있는 것처럼 클래스 템플릿을 생성하여 클래스가 템플릿 매개변수를 유형으로 사용하는 멤버를 가질 수 있습니다. 예를 들어:

template <class T>
class mypair {
    T values [2];
  public:
    mypair (T first, T second)
    {
      values[0]=first; values[1]=second;
    }
};

방금 정의한 클래스는 유효한 유형의 두 요소를 저장하는 역할을 합니다. 예를 들어, 이 클래스의 객체를 선언하여 int값이 115와 36인 두 개의 정수 값 유형을 저장하려면 다음과 같이 작성합니다.

mypair<int> myobject (115, 36);

이 동일한 클래스를 사용하여 다음과 같은 다른 유형을 저장할 개체를 만들 수도 있습니다.

mypair<double> myfloats (3.0, 2.18);

생성자는 이전 클래스 템플릿의 유일한 멤버 함수이며 클래스 정의 자체 내에서 인라인으로 정의되었습니다. 멤버 함수가 클래스 템플릿의 정의 외부에 정의된 경우 template <...>접두사가 앞에 와야 합니다.

// class templates
#include <iostream>
using namespace std;

template <class T>
class mypair {
    T a, b;
  public:
    mypair (T first, T second)
      {a=first; b=second;}
    T getmax ();
};

template <class T>
T mypair<T>::getmax ()
{
  T retval;
  retval = a>b? a : b;
  return retval;
}

int main () {
  mypair <int> myobject (100, 75);
  cout << myobject.getmax();
  return 0;
}

멤버 함수 정의 구문을 확인하세요 getmax.

template <class T>
T mypair<T>::getmax ()

너무 많은 T's에 의해 혼란? 이 선언 에는 세 개의 T's가 있습니다. 첫 번째는 템플릿 매개변수입니다. 두 번째 T는 함수에서 반환된 유형을 나타냅니다. 그리고 세 번째 T(꺾쇠 괄호 사이)도 요구 사항입니다. 이 함수의 템플릿 매개 변수도 클래스 템플릿 매개 변수임을 지정합니다.

템플릿 전문화

특정 유형이 템플릿 인수로 전달될 때 템플릿에 대해 다른 구현을 정의할 수 있습니다. 이것을 템플릿 전문화 라고 합니다 . 예를 들어, 모든 유형의 요소 하나를 저장할 수 있고 해당 값을 증가시키는 라는 멤버 함수가 하나만

있는 매우 간단한 클래스가 있다고 가정해 보겠습니다 . 그러나 유형의 요소를 저장할 때 함수 멤버를 사용하여 완전히 다른 구현을 갖는 것이 더 편리 하다는 것을 알게 되었기 때문에 해당 유형에 대한 클래스 템플릿 전문화를 선언하기로 결정했습니다.mycontainerincreasecharuppercase

// template specialization
#include <iostream>
using namespace std;

// class template:
template <class T>
class mycontainer {
    T element;
  public:
    mycontainer (T arg) {element=arg;}
    T increase () {return ++element;}
};

// class template specialization:
template <>
class mycontainer <char> {
    char element;
  public:
    mycontainer (char arg) {element=arg;}
    char uppercase ()
    {
      if ((element>='a')&&(element<='z'))
      element+='A'-'a';
      return element;
    }
};

int main () {
  mycontainer<int> myint (7);
  mycontainer<char> mychar ('j');
  cout << myint.increase() << endl;
  cout << mychar.uppercase() << endl;
  return 0;
}

다음은 클래스 템플릿 전문화에 사용되는 구문입니다

template <> class mycontainer <char> { ... };

우선, template<>빈 매개변수 목록을 포함하여 클래스 이름 앞에 가 표시됩니다. 이는 모든 유형이 알려져 있고 이 전문화에 템플릿 인수가 필요하지 않기 때문입니다. 그러나 여전히 클래스 템플릿의 전문화이므로 그 자체로 주의해야 합니다.

그러나 이 접두사보다 더 중요한 것은 <char>클래스 템플릿 이름 뒤의 전문화 매개변수입니다. 이 특수화 매개변수 자체는 템플릿 클래스가 특수화되는 유형을 식별합니다( char). 일반 클래스 템플릿과 전문화 간의 차이점을 확인하세요.

template <class T> class mycontainer { ... };
template <> class mycontainer <char> { ... };

첫 번째 줄은 일반 템플릿이고 두 번째 줄은 전문화입니다.

템플릿 클래스에 대한 전문화를 선언할 때 일반 템플릿에서 전문화로의 "상속" 멤버가 없기 때문에 일반 템플릿 클래스와 동일한 경우에도 모든 해당 멤버를 정의해야 합니다.