Усовершенствование CTRL ++ обеспечивает объектную ориентацию для языка сценариев «КАСКАД Цифра».

• Определяемые пользователем типы переменных struct и class
• Модификаторы доступа
• Наследование
• Полиморфизм
• Конструкторы
• Перечисление

Типы переменных, определяемые пользователем — struct & class

Типы переменных struct и class позволяют создавать определяемые пользователем типы данных, которые могут содержать переменные-члены и функции-члены. Члены структуры или класса должны иметь уникальные имена внутри структуры или класса. Следовательно, вы не можете использовать одно и то же имя для функции-члена и переменной-члена.

Модификаторы доступа

Функции — члены и переменные — члены могут быть определены как

• частные: доступ к закрытым элементам может иметь только класс или структура, которые их определяют.
• защищенные: доступ к защищенным элементам может осуществляться классом или структурой, которые их определяют, и всеми производными классами или структурами.
• общедоступные: к общедоступным элементам может быть доступен любой скрипт в пределах области видимости, в которой определен экземпляр этого класса или структуры.

Разница между структурой и классом заключается в модификаторе доступа по умолчанию:

• Члены структуры по умолчанию являются общедоступными.
• Членам класса по умолчанию присвоено значение private.

ПРИМЕР

// definitions

struct EngineHandle

{

string dpName;  // defaults to public

};

// example calls

EngineHandle eHandle;

eHandle.dpName = “engine_001″; // OK, sets dpName of eHandle to engine_001

// definitions

class Valve

{

public open()  { state = 2; }

public close() { state = 1; }

public int getState() { return state; }

int state; // defaults to private

};

// example calls

Valve v;

int valveState;

v.open(); // OK, sets state of v to 2

valveState = v.state; // Error: accessing private member

valveState = v.getState(); // OK, assigns 2 to valveState

In addition, nested data types are also possible (e.g. class in class, struct in class etc.).

ПРИМЕР

// definitions

class Engine

{

public Valve v; // nested class: public member v is of type Valve

};

// example calls

Engine eng;

int valveState;

eng.v.open(); // OK

valveState = eng.v.getState(); // OK

Инициализация

Переменные-члены (статические и нестатические) могут быть инициализированы с помощью выражения. Если выражение является константой, анализатор напрямую вычислит значение и использует его как значение по умолчанию для элемента.

Инициализаторы, которые не являются постоянными, будут оцениваться во время создания объекта, что означает, что вы можете использовать вызов функции для инициализации элемента.

Лучшая практика: это должно выполняться только в функции Object() { [машинный код] }:

ПРИМЕР

// definitions

struct EngineHandle

{

string dpName = “undefined»;

};

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

Статические члены классов CTRL ++, определенные в библиотеках CTRL, глобальные переменные менеджера («global» в библиотеках) и переменные, которые копируются из библиотек в каждый скрипт (например, int x = init(); в библиотеке lib), не должны использовать функции ожидания в инициализаторах.

В качестве первого шага каждый scopeLib и скрипт запускают инициализаторы в следующем порядке:

• статические члены класса (порядок следования в классе или между несколькими классами не определен)
• глобальные экземпляры / переменные в порядке объявления

Это означает, что всякий раз, когда конструктор класса использует статическую переменную своего собственного или другого класса, гарантируется, что статическая переменная уже полностью инициализирована. Пока все инициализаторы не будут завершены, никакие другие потоки не будут выполняться в конкретном сценарии. Если это скрипт на панели и у него есть scopeLib , скрипт не будет выполнять ни один поток в нем, пока не будут завершены все инициализаторы scopeLib.

Более того, когда скрипт на панели пытается запустить общедоступную функцию в PanelRef или другой панели (см. Также invokeMethod()), вызываемая функция не запустится до тех пор, пока scopeLib, содержащий функцию, не завершит инициализаторы.

Наследование

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

ПРИМЕР

// definitions

class Valve

{

public open()  { state = 2; }

public close() { state = 1; }

public int getState() { return state; }

protected string baseType = “Valve»;  // can be accessed from derived class

int state = 1; // private

};

class SlideValve : Valve

{

// access protected base member and own private member

public string getType() { return derivedType + baseType; }

string derivedType = “Slide»;

};

// example calls

SlideValve sv;

int valveState;

sv.open(); // OK, access inherited base method

valveState = sv.getState(); // OK, access inherited base method

DebugN(valveState); // Output: 2

DebugN(sv.getType()); // Output: SlideValve

ПРИМЕЧАНИЕ

Производный класс всегда является производным от базового класса «public».

Члены класса или структуры могут быть статическими, что означает: для всех экземпляров класса существует только один экземпляр этого члена. Можно обращаться к статическому общедоступному члену с помощью обозначения области видимости, например Name::member (см. Пример ниже).

ПРИМЕР

// definitions

class Valve

{

public static int classId = 255;  // can be accessed through scope notation

};

class SlideValve : Valve

{

// inherits static member

};

// example calls

DebugN(Valve::classId); // Output: 255

DebugN(SlideValve::classId); // Output: 255

Перегрузка

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

ПРИМЕР

// definitions

class Valve

{

public int getClassLevel() { return 1; }  

};

class SlideValve : Valve

{

public int getClassLevel()

{

return Valve::getClassLevel() + 1;

}

};

// example calls

Valve v;

SlideValve sv;

DebugN(v.getClassLevel()); // Output: 1

DebugN(sv.getClassLevel()); // Output: 2

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

Нестатические функции-члены могут вызываться с помощью ключевого слова «this». Эта специальная локальная константа указывает на объект, который выполняет функцию-член.

функция Object() { [машинный код] }

У каждого класса может быть метод конструктора, у которого не объявлен возвращаемый тип и то же имя, что и у класса.

Внутри конструктора инициализируются члены класса (см. Пример ниже).

ПРИМЕР

// definitions

class Valve

{

public Valve()

{

state = 1;

}

public int getState() { return state; }

int state;

};

// example calls

Valve v;

DebugN(v.getState()); // Output: 1

Когда пользователь явно не определяет конструктор, CTRL определяет общедоступный конструктор по умолчанию внутри.

Конструктор может иметь определенные параметры. Если этот класс используется в качестве базового класса для другого производного класса, конструктор базового класса должен вызываться в соответствии с определением параметра, например:

class Base{
  public Base(int value) { ... }
};
class Derived : Base
{
  public Derived() : Base(123) { ... }
};

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

ПРИМЕР

// definitions

class Valve

{

public Valve(string s)

{

// initialize all members

// the string elements will be used

// to call dpSet and dpGet in the open and close functions

   elementSet = s + «.Command.setPosition»;

   elementGet = s + «.State.position»;

   position = -1; // note: in this example -1 means undefined

}

public open() { dpSet(elementSet, 100); } // 100 means fully open

public close() { dpSet(elementSet, 0); } // 0 means fully closed

public int getPosition()

{

   dpGet(elementGet, position);

   return position;

}

// produce output for e.g. debugging

public print()

{

   DebugN(«DPE set», elementSet);

   DebugN(«DPE get», elementGet);

}

// members

protected string elementSet;

protected string elementGet;

protected int position;

};

// example calls

Valve v = Valve(«valve_001»);

v.print();

// Output:

// [«DPE set»][«valve_001.Command.setPosition»]

// [DPE get»][«valve_001.State.position»]

Derived class:

// definitions

class SlideValve : Valve

{

public SlideValve(string s) : Valve(s)

{

}

// adds a method to set any value between 0 and 100

public setPosition(int pos)

{

if (pos > 100 || pos < 0)

{

DebugN(«Illegal value», pos);

return;

}

dpSet(elementSet, pos);

}

}

// example calls

SlideValve sv=SlideValve(«valve_001»);

sv.print(); // produces same output as before

sv.setPosition(80); // OK

sv.setPosition(200); // Output: [«Illegal value»][200]

ПРИМЕЧАНИЕ

Вы также можете проверить команду.Элемент setPosition из ранее описанного примера в пункте.

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

Конструктор производного класса автоматически вызовет все конструкторы базового класса, начиная с первого базового класса и заканчивая используемым производным классом.

Конструктор также может быть определен как закрытый, что означает, что никакой экземпляр этого класса не может быть создан, кроме как некоторой статической функцией класса. Если конструктор определен защищенным, класс может использоваться только как базовый класс для какого-либо другого производного класса, у которого есть открытый конструктор.

ПРИМЕЧАНИЕ

Инициализаторы переменных-членов запускаются сначала внутри конструктора класса.

Выражение конструктора класса

Конструктор класса можно использовать как выражение для создания временного экземпляра класса. Выражение конструктора можно использовать везде, где требуется экземпляр класса, например, в качестве аргумента вызова функции.

Пример:

foo(const MyClass &c) {...}
 
foo(MyClass("some value")); //creates a temporary instance of MyClass

деструктор

Деструктор должен иметь то же имя, что и класс, с символом ~ в качестве префикса.

Пример

class Valve
{
~Valve(){}
}

Деструктор всегда является закрытым. Перед именем деструктора не должно быть определено ключевое слово (например, private, public или static). Деструктор запускается при удалении экземпляра этого класса, например, если переменная класса выходит за пределы области видимости или удаляется последний указатель на экземпляр, если экземпляр был создан с помощью «new».

Деструктор производного класса запускается перед деструктором базового класса. Обратите внимание, что деструктор вызывается только в том случае, если конструктор также был выполнен. Например, это не тот случай, когда копируется объект.:

Base c;   //constructor will be executed
Base b=c; //no constructor for b will be executed since this is a copy; 
            only the destructor for c is executed, no destructor for b is executed

ПРИМЕЧАНИЕ

В случае аргументов shared_ptr для функций и т.д. запущенный поток CTRL по-прежнему будет иметь ссылку на экземпляр, пока поток не будет удален. Это также верно для временных объектов, например, в случае func (новый MyClass); деструктор будет запущен не сразу после завершения вызова функции, а когда весь поток CTRL будет остановлен.

Блокирующие функции, такие как dpGet() или delay(), не могут быть выполнены в деструкторе. Таким образом, это позволяет всем деструкторам во всех сценариях панели выполняться и завершаться при закрытии панели до открытия следующей панели. Код в деструкторе должен быть как можно короче для выполнения, поскольку при его выполнении блокируется весь менеджер.

Полиморфизм (виртуальные функции в C ++)

Все функции-члены всегда являются виртуальными, что означает, что интерпретатор вызывает функцию, которая была определена в классе, для которого был создан экземпляр.

ПРИМЕР

// definitions

class Valve

{

// constructor without any parameter

// ensures that member is initialized

// still we can derive from that class

public Valve() { position = 0; }

public open() { position = 100; }

public close() { position = 0; }

public int getPosition() { return position; }

protected int position;

};

class RotoValve : Valve

{

// ranges from -90 to 90

public open() { position = 90; }

public close() { position = -90; }

};

// now we define two functions which take a reference to an instance as parameter

// type must be the base class

openValve(Valve &valve)

{

   Valve.open();

}

closeValve(Valve &valve)

{

   Valve.close();

}

// example calls

Valve v;

RotoValve rv;

openValve(v);

openValve(rv);

DebugN(v.getPosition()); // Output: 100

DebugN(rv.getPosition()); // Output: 90

closeValve(v);

closeValve(rv);

DebugN(v.getPosition()); // Output: 0

DebugN(rv.getPosition()); // Output: -90

}

То есть: вы можете передать любой производный класс по ссылке базового класса, но выполняемая функция будет использоваться из переданного класса (если он существует). Вы также можете назначить производный класс экземпляру базового класса, но не наоборот.

ПРИМЕР

v = rv;  // works

rv = v;  // error

function_ptr

Новый тип данных: function_ptr (указатель на функцию) может содержать указатель на некоторую функцию CTRL script, например, на функцию-член класса. Функция-член должна быть объявлена статической.

ПРИМЕР

// definitions

class Valve

{

public static int getClassId() { return 255; }

};

// example calls

// note: no brackets after getClassId

function_ptr ptr_getId = Valve::getClassId;

DebugN(callFunction(ptr_getId)); // Output: 255

Нестатические функции невозможны, поскольку вызываемая функция не имеет объекта (экземпляра базового класса) и, следовательно, переменной «this».

Тип данных общего указателя

Тип данных shared_ptr, доступный в «КАСКАД Цифра», может использоваться как шаблон.

shared_ptr<int> object1;

Создает объект shared_ptr с именем object1, который указывает на новый объект именованного типа данных. Чтобы создать такой объект, используйте выражение «new».

shared_ptr<Base> object1 = new Base;

В данном случае <Base> — это новый класс. Тип данных, используемый для shared_ptr, может быть либо определяемым пользователем типом (class / struct / enum), либо также стандартным типом данных, таким как int, float и т.д.

shared_ptr<int> object1 = new int;

Вы можете назначить shared_ptr другому shared_ptr того же (или совместимого) типа.

shared_ptr<Base> object2 = object1;

Таким образом, два указателя указывают на один-единственный базовый экземпляр. Когда object1 выходит из области видимости (или ему присваивается nullptr), object2 по-прежнему сохраняет указатель на экземпляр, пока он также не выйдет из области видимости.

ОСТОРОЖНО

Использование указателя на указатель типа shared_ptr< shared_ptr<тип> > не допускается. Также невозможен параметр ссылки на shared_ptr, например: int foo(shared_ptr<int> &ref_to_ptr).

Вы также можете использовать тип данных «void», который создает указатель, который может указывать на любой другой тип данных.

shared_ptr<void> p = new string;

Также допускается понижающая передача shared_ptr:

Классы B наследуются от класса A

shared_ptr<A> pA = new B;
shared_ptr<B> pB;
 
pB = pA;

Новое выражение

Выражение «new» может использоваться как с аргументами, так и без них, например:

shared_ptr<int> pi = new int;                 // no argument
shared_ptr<int> pi = new int();               // no argument
shared_ptr<int> pi = new int(77);             // with initial value
shared_ptr<int> pi = new int(someFunction()); // with initial value
shared_ptr<Enum> pe = new Enum(Enum::One);    // with initial value
shared_ptr<Base> pb = new Base;               // constructor without argument
shared_ptr<Base> pb = new Base(1, 2, 3);      // constructor with arguments

ОСТОРОЖНО

Примечание: указатель на указатель типа shared_ptr< shared_ptr<тип> > не допускается.Также невозможен параметр ссылки на shared_ptr, например: int foo(shared_ptr<int> &ref_to_ptr).

ПРИМЕЧАНИЕ

Вы также можете имитировать эталонный регистр, но только в том случае, если объекты, которые вы хотите сократить, также являются экземплярами shared_ptr, созданными с помощью «new». например:

mapping m;
m[1] = new int;
shared_ptr<int> p = m[1];
p = 77;
 
DebugN(m[1]);  => 77

Автоматическое разыменование

Доступно автоматическое разыменование переменных shared_ptr. Автоматическое разыменование отличается от C++. Это работает аналогично anytype / mixed, поскольку внутренне они также указывают на экземпляр какого-либо другого типа данных, но при их использовании они автоматически получают реальный / конечный объект. например:

mapping m;
 
m["object"] = new Base;
 
m.object.x = 88;  // not as in C++:  m.object->x = 88;

Автоматическое удаление ссылки выполняется всегда, когда есть цель, на которую указывает указатель. например

shared_ptr<string> s1;               // nullptr
shared_ptr<string> s2 = new string;  // points to a string
s1 = s2;    

Новая функция equalPtr(shared_ptr, shared_ptr) позволяет сравнивать, указывают ли оба заданных указателя на один и тот же объект в памяти:

bool equalPtr(s1, s2)

Осторожно

Когда указатели указывают на разные объекты одного типа и им затем присваивается одинаковое значение, функция возвращает «false», поскольку это не один и тот же объект. например:

s1 = new string;
s2 = new string("Hello");
s1 = s2;  /* auto-dereferencing is done. 
            s1 and s2 point to different string objects 
            but both strings now contain the same value "Hello" */
 
equalPtr(s1, s2)  => false

При сравнении с константой nullptr автоматическое удаление ссылки не выполняется, а сравнивается указатель.

Вы можете, например, проверить, содержит ли указатель значение:

Shared_ptr<XY> spTest; 
 
if( spTest ) //compared with nullptr
{
  //...
}

Nullptr — освободить память

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

shared_ptr<string> s = new string;   // memory allocated
s = "Hello";                         // memory written
s = nullptr;                         // memory freed

 

ПРИМЕЧАНИЕ

Прежде чем указателю можно будет назначить новый указатель, ему должно быть присвоено значение nullptr, в противном случае старый объект будет перезаписан. Переназначение также может быть выполнено с помощью функции assignPtr().

ОСТОРОЖНО

Обратите внимание, что некоторые ключевые слова CTRL используются внутри компании и, следовательно, их больше нельзя использовать для других целей, таких как имена переменных: shared_ptr, new, delete, nullptr

ОСТОРОЖНО

Если вы создаете класс, и объект этого класса содержит shared_ptr, и этот shared_ptr указывает на сам объект, эта ссылка никогда не выходит за пределы области видимости и не удаляется автоматически. Вы должны установить переменной-члену значение nullptr .Это также применимо, если два объекта указывают друг на друга, объекты не удаляются автоматически и оба никогда не выйдут за пределы области видимости. Установите для переменных значение nullptr.

Вектор

Вектор — это настраиваемый тип данных (аналогичный shared_ptr или переменным dyn_), который может содержать несколько элементов указанного типа.

Синтаксис:

vector<data_type>

Пример:

Вектор , содержащий список элементов int:

vector<int>

Типом также может быть другой вектор:

vector< vector<int> > 

ПРИМЕЧАНИЕ

Запись vector<вектор<int>> синтаксически некорректна, поскольку два «>» подряд без пробела друг между другом обрабатываются как оператор сдвига.

К элементам внутри вектора можно обращаться через их индекс. Оператор индекса [] вектора начинается с 0 (НУЛЯ). В векторах оператор индекса может использоваться только для элементов, которые уже есть в векторе. Невозможно присвоить значение индексу, которого еще нет. Это означает, что дополнительные элементы должны быть добавлены с помощью определенных функций (например: функции-члены append() или prepend()).

vector<int> v = makeVector(1, 2, 3, 4);
 
v.append(5);    // adds element as last element
v.prepend(0);   // adds element as first element

Векторы могут содержать элементы только одного определенного типа, что означает, что вектор<int> может содержать только значения int. Исключением являются vector<void>, vector<anytype> и vector<mixed> . Если вектор содержит класс или shared_ptr к классу, также возможно добавить производные классы (или shared_ptr к нему) к вектору.

ПРИМЕЧАНИЕ

Вектор нельзя преобразовать напрямую в строку. Используйте jsonEncode (vector), если вы хотите сериализовать вектор в строку.

Векторы и типы данных dyn

Функциональность вектора сравнима с различными типами данных dyn_. Пока типы данных одинаковы, вектор может быть назначен _dyn и наоборот. Это означает, что вектор также может быть инициализирован функциями makeDyn. например.:

vector<string> v = makeDynString("a","b","c");

В качестве особого случая также возможно присвоить любому вектору значение dyn_anytype или dyn_mixed .

Самая большая разница между векторами и переменными dyn_ — это индекс. Для векторов этот индекс начинается с 0, в то время как переменные dyn_ начинаются с 1. Это влияет, например, на итерацию с циклом for.:

vector<int> v = makeVector(1, 2, 3, 4);
for (int i = 0; i < v.count(); i++)
{
  DebugN("new value:", v[i]);
}
 
dyn_int dynInt = makeDynInt(1, 2, 3, 4);
for (int i = 1; i <= dynlen(dynInt); i++)
{
  DebugN("new value:", dynInt[i]);
}

вектор<пустота>

Тип данных void для вектора позволяет добавлять любой тип данных. Вектор<void> похож на dyn_anytype, но dyn_anytype — это dyn_, содержащий переменные anytype , которые сами указывают на любой другой тип. С точки зрения производительности и потребления памяти вектор<void> лучше, поскольку он напрямую содержит конечные указатели на любой заданный тип данных. Следующая функция позволяет создать вектор<void>:

vector<void> makeVector(...)

Вектор<void> может быть назначен любому другому вектору или dyn_ при условии, что типы данных всех элементов соответствуют необходимому типу данных. В противном случае генерируется исключение.

dyn_int di = makeVector(1,2,3);
 
vector< shared_ptr<MyObj> > myVec = makeVector(new MyObj(1), new MyObj(2), new MyObj(3));

Псевдоним типа

Чтобы упростить работу с вложенными типами данных, такими как vector< вектор< shared_ptr<SomeClass> > >, ключевое слово «using» можно использовать следующим образом:

using AliasName = existingType

Псевдоним типа также может использоваться для любого другого типа (например, int, vector, class и т.д.). Он определяется как объявление класса в скрипте вне какой-либо функции. Затем псевдоним можно использовать тем же способом, что и полное выражение, поскольку анализатор преобразует псевдоним в исходный тип. например:

using MyVec = vector < vector< shared_ptr<SomeClass> > >
using myInt = int;
using MyClass = SomeClass;
using vec_str = vector<string>;

Функции-члены стандартных типов данных

Следующие стандартные типы данных предоставляют функции-члены. Они могут вызываться с использованием точечной нотации, аналогично вызову функции класса. В случае функций, которые возвращают целое число без явного объяснения, возвращаемое значение можно игнорировать, поскольку все ошибки будут вызывать исключение. T в следующих списках отображает тип данных. T& показывает, что возвращаемое значение является ссылкой на значение внутри вектора и может быть присвоено ему напрямую. Например. vec.at (12) = 123;

ОСТОРОЖНО

Все функции-члены используют нулевой (0) индекс. Это также относится к dyn_types .

Все функции выдадут исключение, если будет передано неправильное количество аргументов.

отображение

Список всех отображающих функций-членов можно найти здесь.

строка

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

Вектор и dyn_

Список всех функций-членов vector / dyn_* можно найти здесь.

перечисление

Все элементы enum имеют тип «int» и могут быть определены с инициализирующим значением или без него. Повторяющиеся имена недопустимы, допускаются повторяющиеся значения.

Синтаксис:

enum EngineState

{

  Startup,

  Off = 2,

  On = 4,

  Error

};

Инициализирующими значениями могут быть только отдельные постоянные значения или другие, уже определенные имена в перечислении. Как и в C, если элемент не имеет инициализирующего значения, он автоматически получает значение предыдущих элементов + 1, начиная с 0.

В приведенном выше примере результатом является следующий список элементов:

Запуск = 0, Выключено = 2, Включено = 4, Ошибка = 5

Чтобы использовать значение enum где-нибудь в коде, используйте синтаксис:

EnumName::Значение

Вы также можете объявлять переменные типа enum, но им может быть присвоено только значение, которое находится в списке элементов. Если присвоено другое значение, предыдущее значение сохраняется.

Начальным значением экземпляра enum является значение первого элемента.

ПРИМЕР

EngineState eState; // is initialized with 0

eState = 2; // OK, since EngineState::Off is 2

eState = EngineState::On; // OK, since On is in the list

eState = 64; // Not allowed, since 64 is not defined. Value remains 4

Вы не можете напрямую присвоить значение enum значению int. Следовательно, необходимо явное приведение.

ПРИМЕР

int x = EngineState::On; // Not allowed, an explicit cast is required

int x = (int)EngineState::On; // OK

Это также относится к прямому сравнению между значением enum и значением int.

ПРИМЕР

if ((int)_eCONNECION_STATE::STATE_Connected == 1)

ПРИМЕЧАНИЕ

Если целочисленное значение сравнивается со значением enum без явного приведения, в LogViewer можно найти следующее предупреждение:WCCOAui (1), ГГГГ.ММ.ДД hh:mm:ss.ms, IMPL, ПРЕДУПРЕЖДЕНИЕ, 50, вызывается ветвь по умолчанию, IntegerVar, operator=, не удается назначить переменную типа class_vart, код продолжит выполняться, и прерываний не произойдет.

Вызов функции экземпляра класса через объект внутри массива или отображение

Экземпляр класса «Person» внутри массива используется НАПРЯМУЮ (не копируется), и поэтому вызов функции напрямую использует этот экземпляр.

Вы не можете вызвать функцию другого объекта, возвращаемого функцией. Например.

 personMap["katja"].getFriend().sayHello();

В следующем примере показано, как вызвать функцию экземпляра класса напрямую через объект внутри массива или отображение:

class Person
{
  private string m_name;
  private string m_begr;
  private shared_ptr m_friend;
 
  public Person(string name, string begr)
  {
    m_name = name;
    m_begr = begr;
  }
 
  public void setFriend(shared_ptr friend)
  {
    m_friend = friend;
  }
 
  public shared_ptr getFriend()
  {
    return m_friend;
  }
 
  public void sayHello()
  {
    DebugTN(m_begr + ", My name is " + m_name);
  }
};
void main()
{
  shared_ptr katja = new Person("Katja", "Hei");
  shared_ptr josh = new Person("Josh", "Servus");
  shared_ptr john = new Person("John", "Hello");
 
  katja.setFriend(josh);
  josh.setFriend(john);
  john.setFriend(katja);
 
  dyn_anytype persons;
  dynAppend(persons, katja);
  dynAppend(persons, josh);
  dynAppend(persons, john);
 
  for(int i = 1; i <= dynlen(persons); i++)
  {
    persons[i].sayHello();
  }
 
  mapping personMap;
  personMap["katja"] = katja;
  personMap["josh"] = josh;
  personMap["john"] = john;
  personMap["katja"].sayHello();
  //This does not work:
  //personMap["katja"].getFriend().sayHello();
}

RTTI (информация о типе среды выполнения)

CTRL предоставляет следующие две функции для получения информации о типе среды выполнения:

GetType() и getTypeName()

Оба варианта также можно использовать с пользовательскими типами.

• GetType(x) всегда возвращает CLASS_VAR для пользовательских типов данных (enum, struct и class)
• getTypeName(x) возвращает либо <имя класса>, либо <имя перечисления>

ПРИМЕР

testenum myEnum;
 
DebugN(getType(myEnum));
 
DebugN(getTypeName(myEnum));

WCCOAui1:[5570560]     //Integer Value of CLASS_VAR
WCCOAui1:["testenum"]  

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

Определения новых типов в библиотеке делают тип доступным глобально, когда библиотека включена в #uses . В этом случае экземпляры типа должны иметь уникальное имя. Определение в любом другом скрипте, запущенном в CTRL-Manager, аналогичным образом позволяет использовать везде, где доступен файл. Если определение выполняется в ScopeLib, класс доступен только на панели, к которой он прикреплен, и имена могут дублироваться на разных панелях.

Мы рекомендуем хранить библиотеки, содержащие классы, в каталоге проекта в разделе scripts/libs/classes .