Классы — это определяемые пользователем типы данных, которые следуют принципам, установленным объектно-ориентированной парадигмой.
Я почти уверен, что вы где-то слышали о принципах объектно-ориентированного программирования (абстракция, инкапсуляция, наследование и полиморфизм). Если вы читали об этом, но не четко разобрался с концепциями, то я бы порекомендовал вам пройти это, прежде чем продолжить чтение этого поста.

Класс в C++ имеет следующие свойства

  • Набор объектов (экземпляров), имеющих одну и ту же структуру хранения и поведение.
  • Структура C с функциями или операциями
  • Поддержка переменных экземпляра (членов данных) и переменной класса, методов экземпляра (функций-членов) и методов класса.

Прежде чем углубляться дальше, давайте посмотрим на разницу между переменной класса и переменной экземпляра. Переменная экземпляра — это не что иное, как член данных. Допустим, у вас есть класс под названием Student, и вы объявили член с именем name. Теперь вы создаете, скажем, 3 объекта для класса student. Теперь эти 3 объекта имеют собственную копию элемента данных name. Однако все экземпляры используют одну и ту же копию переменной класса. Чтобы все было ясно, посмотрите на код ниже

Ученик класса

общедоступно:

имя строки;

статический целочисленный индекс

int Student::index=0;

внутренний основной(){

Студент s1,s2,s3;

s1.name = «Боб»;

s1.index = 1;

s2.name = «Том»;

s2.index = 2;

s3.name = «Тим»;

cout ‹‹ s1.name ‹‹ s2.name ‹‹ s3.name ‹‹ «\n»;

cout ‹‹ s1.index ‹‹ s2.index ‹‹ s3.index;

Вывод:

Время Боба Тома

2 2 2

Мы можем определить члены класса, используя ключевое слово static. Когда мы объявляем член класса статическим, это означает, что независимо от того, сколько объектов класса вы создаете, существует только одна копия статического члена.

Статический член является общим для всех объектов класса. Все статические данные инициализируются нулем при создании первого объекта, если нет другой инициализации. Мы не можем поместить его в определение класса, но его можно инициализировать вне класса, как это сделано в следующем примере, повторно объявив статическую переменную, используя оператор разрешения области видимости ::, чтобы определить, к какому классу он принадлежит. к. Итак, переменная index является переменной класса, и ее изменения отражаются, когда мы выводим значение index.

Определения классов обычно делятся на 2 файла.

  1. Заголовочный файл (имя-класса.h) — объявления, которые импортируются клиентами имени-класса.
  2. Файл кода (class-name.cpp) — дополнительные определения, должны включать class-name.h

Хорошей практикой кодирования является разделение объявлений классов в файле .h и определений классов в .cpp, хотя это не является обязательным.

Функции-члены объявляются ‹return_type›имя_функции(аргументы). Фактическое определение кода появится в файле кода. Однако для встроенных функций определение может появиться в файле .h. функции? Читать это)

Следующая тема посвящена видимости в C++.

Правила видимости позволят получить прямой доступ к идентификаторам элементов данных и функций-членов из файла заголовка и файла кода.

• Общие правила:

  • Идентификаторы членов видны во всех определениях классов, включая заголовочные файлы и файлы кода.
  • Идентификаторы элементов следуют правилам области, основанным на вложенности единиц в единицы.
  • Последствие. Определения на уровне класса будут:
  • Скрыть определения внешней области одного и того же идентификатора
  • Быть скрытым определениями идентификатора внутренней области видимости
  • Сравните видимость членов через код класса с идентификаторами, не являющимися членами, видимыми только с точки, где они объявлены или определены. Пример: переменная индекса цикла, определенная в заголовке цикла
  • Предполагается, что невстроенные функции-члены, определенные в области действия файла в файле кода, вложены в класс.
  • Используйте оператор разрешения области (::) в файле кода. Он имеет 2 разных формата
  1. ‹class_name›::‹member_id› //для обозначения членов класса вне файла заголовка
  2. ::‹member_id› //дляобозначения глобального идентификатора, скрытого локальным определением

Хорошо, мы обсудили область действия класса и его видимость выше. Теперь давайте обсудим доступность для членов класса. Обратите внимание, что видимость и доступность — это два разных понятия. В некоторых случаях, хотя данные могут быть видны в определенной области, они могут быть недоступны. По мере дальнейшего изучения все станет яснее.

Каждый элемент данных в классе имеет уровень доступа, который определяет, кто имеет право доступа к этому члену. В C++ существует три уровня доступа.

  • частный (по умолчанию)

Этот идентификатор члена доступен только внутри определяющего класса

  • публичный

Этот элемент доступен везде, где он виден (возможно, с использованием полного имени, такого как поле структуры)

  • защищенный

Этот идентификатор члена доступен только внутри определяющего класса и его подклассов.

Частный является наиболее ограничивающим, в то время как общедоступный — наименее. Я хотел бы указать на некоторые общие рекомендации относительно парадигмы объектно-ориентированного программирования и сокрытия информации.

—Элементы данных, как правило, должны быть защищены, иногда даже конфиденциальны.

—Функции-члены в протоколе класса обычно должны быть общедоступными.

—Вспомогательные функции должны быть защищены или закрыты.

При написании подклассов класса C1 члены, определенные классом C1 как защищенные и общедоступные, доступны в коде подкласса, а частные члены — нет.

Я стараюсь свести к минимуму количество текста и предоставить множество примеров кода, но в этом посте содержится много важной информации, о которой нужно позаботиться, если вам нужно написать код хорошего качества. Так что, пожалуйста, потерпите меня. Давайте посмотрим на пример.

пример класса{

целое; //частные члены

целое b;

защищено:

двойные защищенные_данные; //защищенный член

public://public часть класса

example()//это называется конструктор. Поскольку мы не изучали, предположим, что это вспомогательная функция для инициализации члена {

a=0;b=0;

защищенные_данные = 10;

}; // конец класса-примера

класс sub_example:общедоступный пример

целые данные; //частный элемент данных

общедоступно:

sub_example() //конструктор дочернего класса

данные = защищенные_данные * 2; //обратите внимание, что protected_data получена из примера класса и доступна в подклассе

аннулировать printdata(){

cout ‹‹ данные;

}; //конец класса sub_example

внутренний основной()

под_примеры; //создается экземпляр дочернего класса

s.printdata(); // это напечатает значение 20

Обратите внимание, что в приведенном выше фрагменте кода появился новый термин под названием «Конструктор». Мы подробно рассмотрим конструкторы в следующем посте. Пока не беспокойтесь об этом. Основной вывод из приведенного выше кода заключается в том, как дочерний класс получает доступ к защищенному члену базового класса и использует его.

Экземпляры класса создаются статическим, автоматическим или динамическим размещением. Это верно как для встроенных типов, так и для классов и очень похоже на ANSI C.

//объекты построения для примера класса

пример e1; // идентификатор значения и помещается в стек объемлющей функции

пример *e1; // указатель типа example создан, но ни на что не указывает

e1 = новый пример(); //e1 указывает на новый объект примера в куче

Динамическое выделение памяти выполняется с помощью ключевого слова new. В C мы используем malloc для выделения памяти в куче.

  • new всегда вызывает конструкторы, а malloc — нет.
  • malloc возвращает указатель void, который должен быть приведен программистом к типу, в то время как new выполняет автоматическое преобразование типа в запрошенный указатель.

int *i = new int() //возвращает целочисленный указатель

int *i = (int *)malloc(sizeof(int)) //требуется приведение типа int *

  • Всегда важно освобождать память, которая была выделена динамически, иначе она останется в куче, потребляет память и создает хаос (висячие указатели, утечки памяти). Чтобы освободить память, мы используем ключевое слово delete. Обратите внимание, что удаление должно использоваться для переменных, которые были созданы с помощью new. Если вы используете удаление для статических или автоматических или переменных созданный с помощью malloc, компилятор выдаст ошибку.

Прежде чем я завершу этот пост, давайте посмотрим на следующий фрагмент кода.

класс А

ввод;

целое b;

A a1;

Приведенный выше код не компилируется, потому что у вас не может быть идентификатора значения класса в качестве члена класса. Давайте посмотрим на это с логической точки зрения. Когда мы определяем класс, мы говорим компилятору: «Привет! это мой класс, и вам нужно выделить для него столько-то байт». Компилятор соглашается и начинает смотреть на члены. Он знает размер целых чисел, но понятия не имеет, сколько байтов он должен выделить для класса, размер которого не был полностью рассчитан. Поэтому он выдает сообщение об ошибке с указанием неполного типа класса. Попробуйте угадать, что произойдет в этом сценарии.

А *a1; //вместо A a1

Это компилируется абсолютно нормально, поскольку в этом случае компилятору просто нужно знать размер указателя, а не размер класса A. Теперь взгляните на приведенный ниже фрагмент кода.

класс А

ввод;

статический A a1;

Любые предположения относительно того, будет ли это компилироваться или нет?

Ответ: ДА. Он компилируется нормально. Причина в том, что статические переменные выделяются способом, определяемым реализацией, при запуске программы и сохраняются до тех пор, пока программа не завершится. Компилятор при выделении хранилища для класса не учитываются никакие статические переменные, определенные внутри класса, а размер класса не зависит от количества статических переменных, определенных внутри класса.

Размер экземпляра класса A составляет 4 байта из-за целого числа (размер статической переменной опущен)

В этом посте рассмотрены важные темы о классах в C++. В следующем посте мы узнаем об указателе this, дружественных функциях и о том, как C++ отличается от парадигмы объектно-ориентированного программирования.

Если у вас есть какие-либо сомнения по какой-либо из тем, обсуждаемых выше, или если вы чувствуете, что в содержании есть ошибка, напишите комментарий ниже. Давайте учиться вместе

Нравится:

Нравится Загрузка…

Первоначально опубликовано на сайте couthellloworld.wordpress.com 1 августа 2015 г.