Мир состоит из объектов и сам — объект. Исследуя Мир, принято объекты классифицировать по каким-либо признакам. Выделяют классы животных и растений, планет и звезд, атомов и молекул, машин и механизмов, и многие, многие другие. Эта идея положена в основу объектно-ориентированного программирования.
Объектно-ориентированное программирование(ООП) подразумевает описание информационной модели взаимодействия объектов, которые могут содержать данные и алгоритмы. Данные представляются как поля (свойства, атрибуты), а алгоритмы — как процедуры или функции (методы).
Многие из используемых языков программирования (C++, Java, Python, Ruby и т. д.) в большей или меньшей степени поддерживают объектно-ориентированное программирование. Наиболее полно концепция ООП представлена в языке C++. Поэтому на нем написаны все примеры, приведенные ниже.
Классы
Любой объект принадлежит определенному классу. С точки зрения языка C++ класс — это тип, объект — это переменная.
Описать класс на языке C++ можно так:
ES6 #13. Все о Классах в Javascript (+ Примеры + Сравнение c Прототипами)
class ClassName < public: … protected: … private: … >;
Например, класс обыкновенных дробей может быть описан так:
class CFract < public: CFract()<>; CFract(int, int); CFract(const CFract ~CFract()<>; CFract); CFract CFract operator*(const CFract CFract operator/(const CFract CFract operator+(const CFract CFract operator-(const CFract std::string GetStr(); private: int num; int den; protected: int SetDen(int); void Swap(int*, int*); int Nod(int, int); void Reduce(); >;
В секции public: объявляются свойства и методы доступные в самом классе, его потомках. Кроме того, можно обратиться к ним через объект класса, используя точечную запись: имяОбъекта.свойтво/метод. Объявление конструкторов, деструктора, переопределение операций должно располагаться в этой секции.В приведенном примере определены:
CFract()<>; — конструктор без параметров;
CFract(int, int); — конструктор с двумя параметрами: целые числа;
CFract(const CFract — копирующий конструктор.
две операции присваивания(перегрузка операций — тема отдельной статьи):
CFract operator*(const CFract
CFract operator/(const CFract
CFract operator+(const CFract
CFract operator-(const CFract
Обратите внимание, что при объявлении этих методов указаны только типы параметров. Имена понадобятся в определении методов.
Секция private: содержит свойства и методы доступные только в определении методов этого класса. В этой секции объявлены два поля: num(числитель) и den(знаменатель)
Секция protected: содержит свойства и методы доступные в классе и его потомках. В примере здесь объявлены вспомогательные функции.
Определение методов возможна внутри описания класса или после. Первый вариант неудобен для дальнейшей разработки и сопровождения класса. Поэтому будем определять методы после определения всего класса.
Конструктор без параметров определен внутри класса. там не предусмотрено ни каких действий.
C# — Класс и объект. Уроки для маленьких и тупых #8.
Конструктор с параметрами:
CFract::CFract(int sourceNum, int sourceDen)
Может случится, что будет передан знаменатель меньше или равный нулю. Эту неприятность нужно обработать. В случае если передано отрицательное число, то нужно поменять знак и у числителя и у знаменателя, если передан 0, то вывести сообщение об ошибке. Для этого в protected объявим метод int SetDen(int).
int CFract::SetDen(int sourceDen) < if(sourceDen >0) return den = sourceDen; else < if(sourceDen == 0)< std::coutelse < num = -num; return den = -sourceDen; >> >
Тогда конструктор с параметрами примет вид:
CFract::CFract(int sourceNum, int sourceDen)
Кроме метода проверки знаменателя нужен метод сокращения дроби Reduce. Добавим его объявление в секцию protected: , а определение выглядит так:
void CFract::Reduce() < int tmp = Nod(num, den); num = num / tmp; SetDen(den / tmp); >
Для сокращения дроби нужно найти наибольший общий делитель числителя и знаменателя. Добавим метод Nod в секцию protected, а ее определение выглядит так:
int CFract::Nod(int sa, int sb) < int n, d; d = sb; n = (sa<0)? -sa : sa; if(n < d) Swap(d); while(d)< n = n — d; if(n < d) Swap(d); >return n; >
Еще один метод, который необходим в дальнейшем. Он также используется в методе Nod — обмен значениями переменных Swap. Добавим его объявление в секцию protected и определим:
void CFract::Swap(int *a, int *b)
Следующий важный метод — операция присваивания:
CFract source)
Ключевое слово operator указывает на то, что это не просто метод, а операция, которую в дальнейшем можно использовать в выражениях. Например:
Хорошо бы перегрузить операцию присваивания в классе CFract, чтобы иметь возможность читать дробь из строки, то есть чтобы была допустима запись:
Примерная реализация этого метода (не совсем очевидна; пожалуй это тема отдельной статьи):
CFract int a, b; //числитель, знаменатель, счетчик std::string tmp; //временная переменная для числа bool flA; //флаг введен или нет числитель tmp = «»; b = 1; flA = false; for(auto s: source)< if((s >= ‘0’) (s catch(. ) < std::cout tmp = «»; flA = true; > > try < b = ((tmp != «») (flA)) ? std::stoi(tmp) : 1; a = (!flA) ? std::stoi(tmp): 0; >catch(. ) < std::cout num = a; SetDen(b); return *this; >
Определение арифметических операций
Наиболее сложная из всех — операция сложения. Нужно найти наименьший общий знаменатель, дополнительные множители для дробей. Затем сложить произведения числителей на соответствующие дополнительные множители. Примерное определение операции сложения:
CFract CFract::operator+(const CFract CFract tmp; int tmpNod, tmpDen; tmpNod = Nod(den, source.den); tmpDen = (den * source.den) / tmpNod; tmp.num = num * tmpDen / this ->den + source.num * tmpDen / source.den; tmp.SetDen(tmpDen); tmp.Reduce(); return tmp; >
Остальные операции определить гораздо проще. В приложении приведены определения этих операций.
И последнее в этой заметке: объявление и определение принято писать в различных файлах: fract1.h — объявление класса, fract1.cpp — определение методов. Вот эти файлы:
файл fract1.h
#ifndef _FRACT1_H #define _FRACT1_H #include class CFract < public: CFract()<>; CFract(int, int); CFract(const CFract ~CFract()<>; CFract); CFract CFract operator*(const CFract CFract operator/(const CFract CFract operator+(const CFract CFract operator-(const CFract std::string GetStr(); private: int num; int den; protected: int SetDen(int sourceDen); void Swap(int *a, int *b); int Nod(int sa, int sb); void Reduce(); >; #endif
файл fract1.cpp
#include #include #include «fract1.h» CFract::CFract(int sourceNum, int sourceDen) < num = sourceNum; SetDen(sourceDen); >CFract::CFract(const CFract num = source.num; SetDen(source.den); >CFract source) < if(this == num = source.num; SetDen(source.den); return *this; >CFract int a, b; //числитель, знаменатель, счетчик std::string tmp; //временная переменная для числа bool flA; //флаг введен или нет числитель tmp = «»; b = 1; flA = false; for(auto s: source)< if((s >= ‘0’) (s catch(. ) < std::cout tmp = «»; flA = true; > > try < b = ((tmp != «») (flA)) ? std::stoi(tmp) : 1; a = (!flA) ? std::stoi(tmp): 0; >catch(. ) < std::cout num = a; SetDen(b); return *this; > CFract CFract::operator*(const CFract CFract tmp; tmp.num = num * source.num; tmp.SetDen(den * source.den); tmp.Reduce(); return tmp; >CFract CFract::operator/(const CFract CFract tmp; tmp.num = num * source.den; tmp.SetDen(den * source.num); tmp.Reduce(); return tmp; >CFract CFract::operator+(const CFract CFract tmp; int tmpNod, tmpDen; tmpNod = Nod(den, source.den); tmpDen = (den * source.den) / tmpNod; tmp.num = num * tmpDen / this ->den + source.num * tmpDen / source.den; tmp.SetDen(tmpDen); tmp.Reduce(); return tmp; > CFract CFract::operator-(const CFract CFract tmp; int tmpNod, tmpDen; tmpNod = Nod(den, source.den); tmpDen = (den * source.den) / tmpNod; tmp.num = num * tmpDen / den — source.num * tmpDen / source.den; tmp.SetDen(tmpDen); tmp.Reduce(); return tmp; >int CFract::SetDen(int sourceDen) < if(sourceDen >0) return den = sourceDen; else < if(sourceDen == 0)< std::coutelse < num = -num; return den = -sourceDen; >> > std::string CFract::GetStr() < std::ostringstream s; s «; return s.str(); > void CFract::Swap(int *a, int *b) < int tmp = *a; *a = *b; *b = tmp; >int CFract::Nod(int sa, int sb) < int n, d; d = sb; n = (sa<0)? -sa : sa; if(n < d) Swap(d); while(d)< n = n — d; if(n < d) Swap(d); >return n; > void CFract::Reduce() < int tmp = Nod(num, den); num = num / tmp; SetDen(den / tmp); >//перегрузка метода вывода в поток » int main() < CFract a(-1, 2), b(-3, 4); CFract c; c = a + b; std::cout
Функция main нужна только для тестирования. Вообще ее следует определять в отдельном файле.
Источник: habr.com
Классы, структуры и пространства имен
C# является полноценным объектно-ориентированным языком. Это значит, что программу на C# можно представить в виде взаимосвязанных взаимодействующих между собой объектов.
Описанием объекта является класс , а объект представляет экземпляр этого класса. Можно еще провести следующую аналогию. У нас у всех есть некоторое представление о человеке, у которого есть имя, возраст, какие-то другие характеристики. То есть некоторый шаблон — этот шаблон можно назвать классом.
Конкретное воплощение этого шаблона может отличаться, например, одни люди имеют одно имя, другие — другое имя. И реально существующий человек (фактически экземпляр данного класса) будет представлять объект этого класса.
В принципе ранее уже использовались классы. Например, тип string , который представляет строку, фактически является классом. Или, например, класс Console , у которого метод WriteLine() выводит на консоль некоторую информацию. Теперь же посмотрим, как мы можем определять свои собственные классы.
По сути класс представляет новый тип, который определяется пользователем. Класс определяется с помощью ключевого слова сlass :
class название_класса < // содержимое класса >
После слова class идет имя класса и далее в фигурных скобках идет собственно содержимое класса. Например, определим в файле Program.cs класс Person, который будет представлять человека:
class Person
Однако такой класс не особо показателен, поэтому добавим в него некоторую функциональность.
Поля и методы класса
Класс может хранить некоторые данные. Для хранения данных в классе применяются поля . По сути поля класса — это переменные, определенные на уровне класса.
Кроме того, класс может определять некоторое поведение или выполняемые действия. Для определения поведения в классе применяются методы.
Итак, добавим в класс Person поля и методы:
В данном случае в классе Person определено поле name , которое хранит имя, и поле age , которое хранит возраст человека. В отличие от переменных, определенных в методах, поля класса могут иметь модификаторы, которые указываются перед полем. Так, в данном случае, чтобы все поля были доступны вне класса Person поля определены с модификатором public .
При определении полей мы можем присвоить им некоторые значения, как в примере выше в случае переменной name . Если поля класса не инициализированы, то они получают значения по умолчанию. Для переменных числовых типов это число 0.
Также в классе Person определен метод Print() . Методы класса имеют доступ к его поля, и в данном случае обращаемся к полям класса name и age для вывода их значения на консоль. И чтобы этот метод был виден вне класса, он также определен с модификатором public .
Создание объекта класса
После определения класса мы можем создавать его объекты. Для создания объекта применяются конструкторы . По сути конструкторы представляют специальные методы, которые называются так же как и класс, и которые вызываются при создании нового объекта класса и выполняют инициализацию объекта. Общий синтаксис вызова конструктора:
new конструктор_класса(параметры_конструктора);
Сначала идет оператор new , который выделяет память для объекта, а после него идет вызов конструктора .
Конструктор по умолчанию
Если в классе не определено ни одного конструктора (как в случае с нашим классом Person), то для этого класса автоматически создается пустой конструктор по умолчанию, который не принимает никаких параметров.
Теперь создадим объект класса Person:
Для создания объекта Person используется выражение new Person() . В итоге после выполнения данного выражения в памяти будет выделен участок, где будут храниться все данные объекта Person. А переменная tom получит ссылку на созданный объект, и через эту переменную мы можем использовать данный объект и обращаться к его функциональности.
Обращение к функциональности класса
Для обращения к функциональности класса — полям, методам (а также другим элементам класса) применяется точечная нотация точки — после объекта класса ставится точка, а затем элемент класса:
объект.поле_класса объект.метод_класса(параметры_метода)
Например, обратимся к полям и методам объекта Person:
Консольный вывод данной программы:
Добавление класса
Обычно классы помещаются в отдельные файлы. Нередко для одного класса предназначен один файл. Если мы работаем над проектом вне среды Visual Studio, используя .NET CLI, то нам достаточно добавить новый файл класса в папку проекта. Например, добавим новый файл, который назовем Person.cs и в котором определим следующий код:
class Person < public string name = «Undefined»; public void Print() < Console.WriteLine($»Person «); > >
Здесь определен класс Person с одним полем name и методом Print.
В файле Program.cs , который представляет основной файл программы используем класс Person:
Person tom = new Person(); tom.name = «Tom»; tom.Print(); // Person Tom
Visual Studio предоставляет по умолчанию встроенные шаблоны для добвления класса. Для добавления класса нажмем в Visual Studio правой кнопкой мыши на название проекта:
В появившемся контекстном меню выберем пункт Add -> New Item. (или Add -> Class. )
В открывшемся окне добавления нового элемента убедимся, что в центральной части с шаблонами элементов у нас выбран пункт Class . А внизу окна в поле Name введем название добавляемого класса — пусть он будет назваться Person :
В качестве названия класса можно вводить как Person, так и Person.cs. И после нажатия на кнопку добавления в проект будет добавлен новый класс, в котором можно определить тот же код и также использовать в файле Program.cs.
Таким образом, мы можем определять классы в отдельных файлах и использовать их в программе.
Источник: metanit.com
Классы в C++ — урок 10
Весь реальный мир состоит из объектов. Города состоят из районов, в каждом районе есть свои названия улиц, на каждой улице находятся жилые дома, которые также состоят из объектов.
Практически любой материальный предмет можно представить в виде совокупности объектов, из которых он состоит. Допустим, что нам нужно написать программу для учета успеваемости студентов. Можно представить группу студентов, как класс языка C++. Назовем его Students .
- Основные понятия
- Модификаторы доступа public и private
- Программа учета успеваемости студентов
- Отделение данных от логики
- Создание объекта через указатель
- Конструктор и деструктор класса
Основные понятия
Классы в программировании состоят из свойств и методов. Свойства — это любые данные, которыми можно характеризовать объект класса. В нашем случае, объектом класса является студент, а его свойствами — имя, фамилия, оценки и средний балл.
У каждого студента есть имя — name и фамилия last_name . Также, у него есть промежуточные оценки за весь семестр. Эти оценки мы будем записывать в целочисленный массив из пяти элементов. После того, как все пять оценок будут проставлены, определим средний балл успеваемости студента за весь семестр — свойство average_ball .
Методы — это функции, которые могут выполнять какие-либо действия над данными (свойствами) класса. Добавим в наш класс функцию calculate_average_ball() , которая будет определять средний балл успеваемости ученика.
- Методы класса — это его функции.
- Свойства класса — его переменные.
// считаем среднее арифметическое average_ball = sum / 5.0; > // Имя студента std::string name; // Фамилия std::string last_name; // Пять промежуточных оценок студента int scores[5]; private: // Итоговая оценка за семестр float average_ball; >;
Функция calculate_average_ball() просто делит сумму всех промежуточных оценок на их количество.
Модификаторы доступа public и private
Все свойства и методы классов имеют права доступа. По умолчанию, все содержимое класса является доступным для чтения и записи только для него самого. Для того, чтобы разрешить доступ к данным класса извне, используют модификатор доступа public . Все функции и переменные, которые находятся после модификатора public , становятся доступными из всех частей программы.
Закрытые данные класса размещаются после модификатора доступа private . Если отсутствует модификатор public , то все функции и переменные, по умолчанию являются закрытыми (как в первом примере).
Обычно, приватными делают все свойства класса, а публичными — его методы. Все действия с закрытыми свойствами класса реализуются через его методы. Рассмотрим следующий код.
// Получение среднего балла float get_average_ball() < return average_ball; >std::string name; std::string last_name; int scores[5]; private: float average_ball; >;