Difference between revisions of "Arma Reforger:Object Oriented Programming Advanced Usage"

From Bohemia Interactive Community
Jump to navigation Jump to search
(Add modded section)
m (Fix typo, Add super link)
Line 102: Line 102:
  
 
A mod can inherit/replace an existing class with the use of the {{hl|modded}} keyword.<br>
 
A mod can inherit/replace an existing class with the use of the {{hl|modded}} keyword.<br>
It is used to inject inherited class into class hierarchy without modifying other scripts (especially suitable in modding). A modded class behaves like a class inherited from the original class (one can use {{hl|super}} to access the original class). When a modded class is declared, the modded class will be instanced instead of the original class. Only classes within the same module can be modded (to mod a class in e.g {{hl|GameLib}} module, the modded class has to be placed in the {{hl|GameLib}} module).
+
It is used to inject inherited class into class hierarchy without modifying other scripts (especially suitable in modding). A modded class behaves like a class inherited from the original class (one can use {{hl|[[Arma Reforger:Object Oriented Programming Basics#super|super]]}} to access the original class). When a modded class is declared, the modded class will be instanced instead of the original class. Only classes within the same module can be modded (to mod a class in e.g {{hl|GameLib}} module, the modded class has to be placed in the {{hl|GameLib}} module).
  
 
<syntaxhighlight lang="C#">
 
<syntaxhighlight lang="C#">
Line 110: Line 110:
 
void Say()
 
void Say()
 
{
 
{
Print("Hello orginal");
+
Print("original Say method");
 
}
 
}
 
};
 
};
Line 119: Line 119:
 
void Say()
 
void Say()
 
{
 
{
Print("Hello modded");
+
Print("modded Say method");
 
super.Say();
 
super.Say();
}
+
}F
 
};
 
};
 
   
 
   
Line 127: Line 127:
 
{
 
{
 
A a = new A(); // "modded class A" is instanced
 
A a = new A(); // "modded class A" is instanced
a.Say(); // prints 'Hello modded' and 'Hello orginal'
+
a.Say(); // prints 'modded Say method' then 'original Say method'
 
}
 
}
 
</syntaxhighlight>
 
</syntaxhighlight>

Revision as of 18:04, 28 June 2022

This guideline requires the understanding of Object Oriented Programming Basics.


Casting

Casting is the act of "presenting" a value as another type. For example, if a class hierarchy is Animal > Dog > Cocker, a dog is an animal, a cocker is a dog (that is an animal), but a dog is not especially a cocker.

class Animal {}
class Dog : Animal {}
class Cocker : Dog {}
class Labrador : Dog {}

Upcasting

Upcasting means seeing the class as one of its parents:

void Method()
{
	Cocker cocker = new Cocker();
	Animal animal = cocker;			// OK, as a cocker is an animal
	string sentence = cocker;		// error: cocker does -not- inherit from string
};

Downcasting

Downcasting means seeing a parent class as a specific child - this must be done by manually casting:

void Method(Dog dog)
{
	Cocker cocker1 = dog;				// error: "Dog" is too generic to be casted as Cocker - it could be e.g a Labrador
	Cocker cocker2 = Cocker.Cast(dog);	// OK: manual casting tells the code "the developer knows what he is doing"
										// if 'dog' is not castable as a Cocker, null is returned - the code does not crash

	Cocker cocker3;
	cocker3.Cast(dog);					// alternative method
}

Manual Casting

void Method()
{
	float value1 = 4.9;
	int value2 = value1;						// value2 = 4 as integer casting -truncates- the value, not rounds it
	string value3 = "result = " + (bool)value2;	// "result = true", as a non-zero integer is true when casted to bool
}


Template

A template is a class that allows a generic management for multiple types. Its methods cannot assume anything about the type.

The generic type is by convention declared by the T letter.
// template class Item with generic type T
class Item<Class T>
{
	protected T m_data;

	void Item(T data)
	{
		m_data = data;
	}

	void SetData(T data)
	{
		m_data = data;
	}

	T GetData()
	{
		return m_data;
	}

	void PrintData()
	{
		Print(m_data);
	}
};
void Method()
{
	Item<string> stringItem = new Item<string>("Hello!");	// template class Item declared with type "string". In Item<string> class, all Ts are substituted with 'string'
	Item<int> intItem = new Item<int>(72);					// template class Item declared with type "int". In Item<int> class, all Ts are substituted with 'int'

	string_item.PrintData();	// prints "m_data = 'Hello!'"
	int_item.PrintData();		// prints "m_data = 72"
}


Modding

A mod can inherit/replace an existing class with the use of the modded keyword.
It is used to inject inherited class into class hierarchy without modifying other scripts (especially suitable in modding). A modded class behaves like a class inherited from the original class (one can use super to access the original class). When a modded class is declared, the modded class will be instanced instead of the original class. Only classes within the same module can be modded (to mod a class in e.g GameLib module, the modded class has to be placed in the GameLib module).

// game
class A
{
	void Say()
	{
		Print("original Say method");
	}
};
 
// mod
modded class A // this class automatically inherits from the original class A
{
	void Say()
	{
		Print("modded Say method");
		super.Say();
	}F
};
 
void Test()
{
	A a = new A();	// "modded class A" is instanced
	a.Say();		// prints 'modded Say method' then 'original Say method'
}