Определение и использование методов

Пример 14.6. Использование метода класса для сложения двух целых чисел.

 

#include "stdafx.h"

using namespace System;

class MyClass {

public:

int sum(int x, int у) { // Определение метода

      return x + у;

}

};

int main() {

MyClass mc;              // Создание объекта

// Вызов метода

Console::WriteLine("23 + 11 = {0}", mc.sum(23, 11));

                        // Вывод: 23 + 11 = 34

Console:: ReadLine ();

return 0;

}

 

Пример 14.7. Использование полей и методов класса.

 

#include "stdafx.h"

using namespace System;

class MyClass {

private:

int x;              // Объявление закрытого поля

public:

int get _ x () {        // Определение метода

   return x;

}

void set _ x (int у) {      // Определение метода

    x = у;

}

} obj;              // Объявление объекта

int main () {

obj. set _ x (10); // Изменение значения закрытого поля через метод

// Получение значения закрытого поля через метод

Console::WriteLine("obj.x = {0}", obj.get_x());

                                 // Вывод: obj.x = 10

Console::ReadLine();

return 0;

}

 

Обратиться к полю внутри метода явным образом можно и через указатель this, который неявно передается в каждый метод. Доступ к полю в этом случае осуществляется с помощью оператора ->, например:

 

void set(int value) {

if (value >= 0 && value <= 200)

   this->field = value; // или (*this).field = value;

}

 

В языке C++ предусмотрено неполное объявление класса (аналогично прототипам функций), имеющее следующий формат:

 

class <Имя_класса>;

 

Листинг 14.8. Использование неполного объявления класса.

 

#include "stdafx.h"

Class A;  // Неполное объявление класса. Если убрать, будет ошибка

class B {            // Определение класса

public:

int func(A &obj); // Объявление метода внутри класса

};

class A {            // Определение класса

public:

int х;           // Член класса

A(int а) { х = а; } // Конструктор класса

};

int B::func(A &obj) { // Определение метода func класса B

return obj. х;

}

int main() {

A a(21);  // Объявление и инициализация экземпляра класса

B b;           // Объявление экземпляра класса

System:: Console:: WriteLine (b. func (a)); // Вывод: 21

System::Console::ReadLine();

return 0;

}

 

 

Перегрузка методов

Пример 14.9. Использование перегруженных методов класса.

 

#include "stdafx.h"

using namespace System;

class MyClass {

public:

int max(int i1, int i2) {      // Определение метода

   return (i1 > i2)? i1: i2;

}

double max(double d1, double d2) { // Определение метода

      return (d1 > d2)? d1: d2;

}

};

int main() {

MyClass mc;                // Создание экземпляра класса

int i = mc.max(13, 4);     // Вызов метода

double d = mc.max(32.9, 14.4); // Вызов метода

Console:: WriteLine (" Наибольшим из 13 и 4 является {0}. ", i);

Console:: WriteLine (" Наибольшим из 32,9 и 14,4 является {0}. ", d);

Console:: ReadLine ();

return 0;

}

/* Вывод:

Наибольшим из 13 и 4 является 13.

Наибольшим из 32,9 и 14,4 является 32,9.

*/

 

Конструкторы и деструкторы

Объявление объекта класса с помощью конструктора:

 

<Имя_класса> <Название_перененной>;

или

<Имя_класса> <Название_переменной> = <Имя_класса>();

 

Объявление объекта с указанием параметров может выглядеть следующим образом:

 

<Имя_класса> <Название_переменной>(<Параметр1>[,...,

                              <ПараметрN>]);

или

<Имя_класса> <Названне_переменной> =

        <Имя_класса>(<Параметр1>[,..., <Параметр N >]);

 

Пример 14.10. Создание класса с несколькими конструкторами и различные способы создания экземпляра класса (перегрузка конструкторов).

 

#include "stdafx.h"

using namespace System;

class MyClass {

int х _, у _;

public:

MyClass () { х_ = 0; у_ = 0; }         // Конструктор 1

MyClass (int х) { х_ = х; у_ = 0; }    // Конструктор 2

MyClass (int х, int у) { х_ = х; у_ = у; } // Конструктор 3

int get_x() { return х_; }

};

int main () {

MyClass obj 1;                 // Вызывается конструктор 1

MyClass obj 2 = MyClass ();      // Вызывается конструктор 1

MyClass obj 3(10);             // Вызывается конструктор 2

MyClass obj 4 = MyClass (20);       // Вызывается конструктор 2

MyClass obj 5(30, 3);          // Вызывается конструктор 3

MyClass obj 6 = MyClass (40, 4);   // Вызывается конструктор 3

// MyClass obj7();            // Ошибка

Console::WriteLine(obj1.get_x()); // Вывод: 0

Console::WriteLine(obj2.get_x()); // Вывод: 0

Console::WriteLine(obj3.get_x()); // Вывод: 10

Console::WriteLine(obj4.get_x()); // Вывод: 20

Console::WriteLine(obj5.get_x()); // Вывод: 30

Console::WriteLine(obj6.get_x()); // Вывод: 40

Console:: ReadLine ();

return 0;

}

 

Перед уничтожением объекта автоматически вызывается метод, называемый деструктором.

 

~<Имя_класса>() {

<тело_деструктора>

}

 

Пример 14.11. Порядок вызова конструкторов и деструкторов при создании и удалении нескольких объектов. Чтобы увидеть результат выполнения деструкторов следует запускать программу нажатием комбинации клавиш <Ctrl>+<F5>.

 

#include "stdafx.h"

#include <iostream>

class MyClass {

int x_;

public:

MyClass (int x) { // Конструктор

x _ = x;

Console::WriteLine("MyClass(int x) {0}", x_);

}

~MyClass() {   // Деструктор

Console::WriteLine("~MyClass() {0}", x_);

}

} obj 1(1), obj 2(2); // Создание глобальных объектов

int main () {

MyClass obj 3(3); // Создание локального объекта

Console:: WriteLine (" main ()");

Console::ReadLine();

return 0;

}

/* Вывод:

MyClass(int x) 1

MyClass(int x) 2

MyClass(int x) 3

main ()

~ MyClass () 3

~ MyClass () 2

~ MyClass () 1

*/

 

 

Статические члены класса

 

Пример 14.12. Использование статических полей класса.

 

#include "stdafx.h"

using namespace System;

class MyClass {    // Объявление класса

private:

static int N;  // Объявление закрытого статического поля

public:

static int M;  // Объявление открытого статического поля

MyClass () {    // Объявление конструктора

N ++;         // Обращение к полю внутри класса

}

int N 2() {     // Объявление метода

   return N * N; // Обращение к полю внутри класса

}

};

Int MyClass:: N;    // Определения