Точка, стрелка и двойное двоеточие при программировании классов и объектов в С++
В С++ есть такое понятие как область видимости класса. Вообще в С++ есть понятие областей видимости и вот среди них одна из областей видимости — это область видимости класса.
- Локальная область видимости — видимость только внутри блока
- Глобальная область видимости — видимость на уровне файла
- Область видимости класса — видимость только внутри класса, но не за его пределами
Область видимости класса применима к именам, определенным в классе, таким как имена данных-членов и функций-членов класса. Существование такой области видимости позволяет удобно использовать одни и те же названия для функций или переменных внутри разных классов.
Вне класса и вне функций класса для доступа к элементам, сокрытым областью видимости класса, в зависимости от ситуации применяют операции:
Прямая операция членства
Косвенная операция членства
Операция разрешения контекста
.
->
::
Какая из операций используется зависит от контекста, в котором используется название класса. Самый простой и понятный вариант — использование операции "точка". Используем объект и с помощью точки делаем запрос на какую-то часть класса, будь то функция или переменная, открытая классом.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
//Листинг #1 Использование точки как операции доступа к элементу класса #include <cstring> #include <iostream> using std::cout; /*НАШ КЛАСС*/ class MyClass{ public: int x; //Переменная открыта классом, но сокрыта областью видимости класса void show(){ cout << "hello\n"; } //функция открыта классом, но сокрыта областью видимости класса }; int main(){ MyClass student; student.x = 100; //ипользовали запрос с помощью точки cout << student.x << '\n'; student.show(); //ипользовали запрос с помощью точки } |
Использование точки обычно самый привычный способ (для тех, кто не переходил с каких-то специфических кодов), поэтому, как правило, вопросов с точкой не возникает: есть объект и его возможности задействования с помощью запроса через точку.
Чуть сложнее дело обстоит со стрелкой. Сколько бы лет ни прошло, всегда будут новички, которым стрелка окажется неясной. Конечно, если объяснить, то всё ясно, но как-то так вышло, что сначала люди не понимают указатели, потом не понимают операцию ->. Эта операция выполняет ту же роль, что точка, но предназначена для облегчения восприятия кода. Когда используются указатели, хочешь или не хочешь, но в С++ код становится сложным для восприятия, и этот момент в случае с объектами был немного упрощён:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
//Листинг #2 Использование стрелки как операции доступа к элементу класса #include <cstring> #include <iostream> using std::cout; /*НАШ КЛАСС*/ class MyClass{ public: int x; //Переменная открыта классом, но сокрыта областью видимости класса void show(){ cout << "hello\n"; } //функция открыта классом, но сокрыта областью видимости класса }; int main(){ MyClass *student = new MyClass; student -> x = 100; //<---- Так просто проще, чем через точку delete student; MyClass *ptr = new MyClass; (*ptr).x = 100; //<--- а так обычно запутываешься delete ptr; //Оба варианта одно и то же } |
Если внутренний для класса элемент указатель, а объект класса не является указателем, то обычно используется точка:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 |
//Листинг #3 Использование точки как операции доступа к элементу класса #include <cstring> #include <iostream> using std::cout; /*НАШ КЛАСС*/ class MyClass{ public: int *x; //Переменная открыта классом, но сокрыта областью видимости класса void show(){ cout << "hello\n"; } //функция открыта классом, но сокрыта областью видимости класса /*с помощью конструктора выделяем память внутреннему для класса указателю*/ MyClass(){ x = new int; } /*с помощью деструктора зачищаем память от внутреннего для класса указателя*/ ~MyClass(){ delete x; } }; int main(){ MyClass student; *student.x = 100; //Точка используется к разыменованному объекту (*student).x cout << *student.x << '\n'; } |
В общем, стрелка обычно используется, если на объект указывает указатель, а точка если объект сам по себе.
Операция двойного двоеточия называется операцией разрешения области видимости не просто так. Прежде всего двойное двоеточие является уточнением. Фактически двойное двоеточие расширяет область видимости компилятору для поиска названий. Если говорить о классах, то такую использовать можно для выносимых за класс данных класса. Это помогает избежать неоднозначности в случае использования нескольких классов, внутри которых могут оказаться одни и те же названия. Двойным двоеточием уточняется принадлежность элемента к классу и компилятор не затруднён в выборе правильного класса. Кроме этого, в классе двойное двоеточие может применяться к статической переменной класса. По большому счёту статическая переменная класса является глобальной переменной, но прикрытой областью видимости класса. Поскольку статическая переменная класса глобальная, ей не имеет значения, построен объект или не построен и она не зависит от объектов класса. Если обычные переменные внутри класса могут использоваться как независимые переменные независимыми объектами такого класса, то статическая переменная класса привязана ко всем объектам класса.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 |
//Листинг #3 Использование точки как операции доступа к элементу класса #include <cstring> #include <iostream> class MyClass; using std::cout; /*НАШ КЛАСС*/ class MyClass{ public: static int x; //объявление статической переменной, открыта классом,скрыта областью видимости класса static int y; //объявление статической переменной, открыта классом,скрыта областью видимости класса }; int MyClass::x; //уточняем принадлежность к области видимости класса int ::MyClass::y; //уточняем принадлежность к области видимости класса и уточняем дальше принадлежность к области видимости глобального пространства имён int main(){ MyClass::x = 100; MyClass::y = 200; cout << "MyClass::x == " << MyClass::x << '\n'; cout << "MyClass::y == " << MyClass::y << '\n'; } |
Статическую переменную класса надо определять вне функций, это как с глобальными, ибо она глобальная. Т. е. локально внутри какой-то функции нельзя инициализировать значением статическую переменную класса. А если мы такую не инициализируем, то ёё как бы не будет существовать, то, что она объявлена внутри класса, не порождает её саму. Но суть темы иная. Суть темы в том, что если что-то сокрыто областью видимости, то иногда можно немножко приоткрыть заслонки, чтобы обращаться к сокрытому, как в примере со тсатической переменной класса. В зависимости от ситуации может потребоваться любой из показанных трёх вариантов.
-
Статическая переменная одна на все объекты класса.
12345678910111213141516171819202122232425//Листинг #a1#include <cstring>#include <iostream>class MyClass;using std::cout;/*НАШ КЛАСС*/class MyClass{public:static int x; //объявление статической переменной, открыта классом,скрыта областью видимости классаMyClass(){x++;}};int MyClass::x;int main(){MyClass cx;MyClass cy;cout << MyClass::x << '\n'; //Два раза сработал конструктор по умолчанию, x нарастилось до 2}
И как упоминалось ранее (а многим новичкам уже не первый день знакомо), операция двойного двоеточия уточняет принадлежность некоторых функций к классам:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 |
//Листинг #3 Использование точки как операции доступа к элементу класса #include <cstring> #include <iostream> class MyClass; using std::cout; /*НАШ КЛАСС*/ class MyClass{ public: void foo(); //Одно и то же название функции }; class Student{ public: void foo(); //В разных классах }; void MyClass::foo(){ //<-- уточняем принадлежность имени функции к классу cout << "foo from MyClass\n"; } void Student::foo(){ //<-- уточняем принадлежность имени функции к классу cout << "foo from Student\n"; } int main(){ MyClass m; Student s; m.foo(); s.foo(); } |
Просто запомните, что где операция двойного двоеточия, там скорее всего уточняют область видимости. Эта операция не ограничивается классами и как бы независима от классов. Т. е. она происходит не из возможностей классов, а из другой области. Просто её достаточно удобно применять в некоторых случаях к элементам классов.
3 комментария на «“Точка, стрелка и двойное двоеточие при программировании классов и объектов в С++”»
Добавить комментарий
Случайная книга в электронном формате
❗
Хорошая статья, спасибо!
Но вот такая конструкция встретилась:
Где осталось не понятным применение двоеточия перед вызовом функций в двух последних строках. Была в кодах
С++ при использовании библиотеки Qt3 под FreeBSD.
Этот пример можно не объяснять.
Ответ нашелся: функция SetShow(bool On) принадлежит текущему классу, а SetShow(pbShowInList, On) есть глобальная функция, то есть совсем другая и описана где-то вне этого класса. А чтобы вызвать эту глобальную функцию и ставятся два двоеточия перед ее именем.