Is there C++ equivalent of Objective-C Instance and Class Methods? - c++

Question

I am learning C++ with Xcode (cocos2d-x).
A regular c++ void method I think is equivalent to an obj-c -void Instance method.
Is there is a c++ equivalent of the obj-c +void Class method?
Thanks

Answer 1

There is no direct equivalent to class methods in C++; however, in many cases C++ static methods can be used in place of class methods.
For example, this Objective-C code:
#interface MyClass : NSObject
{
int _number;
}
+ (MyClass*)newInstance;
- (void)instanceMethod;
#end
#implementation MyClass
+ (MyClass*)newInstance
{
return [[self alloc] init];
}
- (void)instanceMethod
{
_number = 123;
std::cout << _number;
}
#end
int main(void)
{
MyClass* foo = [MyClass newInstance];
[foo instanceMethod];
return 0;
}
is roughly equivalent to this C++ code:
class MyClass
{
int _number;
public:
static MyClass* newInstance();
void instanceMethod();
};
MyClass* MyClass::newInstance()
{
return new MyClass();
}
void MyClass::instanceMethod()
{
_number = 123;
std::cout << _number;
}
int main(void)
{
MyClass* foo = MyClass::newInstance();
foo->instanceMethod();
return 0;
}
That example also illustrates one of the differences between class methods and static methods.
+newInstance will be inherited by subclasses and will always work correctly (it will always return an instance of a subclass). It can also be overridden by a subclass.
Static methods like MyClass::newInstance() cannot be inherited or overridden. It will always return an instance of MyClass.
So when you're porting code between Objective-C and C++ there are cases when you cannot use static methods in place of class methods. But for most cases, C++ static methods are a fine replacement.

Answer 2

class SomeClass {
public:
static void someMethod();
};

Answer 3

The equivalent of class methods in C++ would be static functions.
static return_type function_name(parameters);
Just like in Objective-C, in static functions you cannot reference instance variables (since there's no instance), only static variables.

Answer 4

For example.
class A{
public:
static void doIt();
};
Then you can call function doIt with:
void main()
{
A::doIt();
}

Answer 5

Objective-C has implicit metaclasses as explored in "What is a meta-class in Objective-C?" article. The full power of metaclasses is not unleashed, however. It would require multiple inheritance support and other technical decisions, as described in famous "Putting Metaclasses to Work" book. That was probably too complex for Objective-C authors, so they decided to hide metaclasses in Objective-C.
Objective-C targets Objective-C runtime (obj.dll or libobjc.dylib), and there were C++ compilers (DTS C++, Direct-to-SOM C++) targetting SOM the same way. This makes DTS C++ closer to Objective-C than C++ in its design. I managed to get old Windows DTS C++ compiler running on Windows 8 this way:
Download VAC 3.5 fixpak 9 from IBM FTP. This fixpak contain many files, so you don't even need to full compiler (I have 3.5.7 distro, but fixpak 9 was big enough to do some tests).
Unpack to e. g. C:\home\OCTAGRAM\DTS
Start command line and run subsequent commands there
Run: set SOMBASE=C:\home\OCTAGRAM\DTS\ibmcppw
Run: C:\home\OCTAGRAM\DTS\ibmcppw\bin\SOMENV.BAT
Run: cd C:\home\OCTAGRAM\DTS\ibmcppw\samples\compiler\dts
Run: nmake clean
Run: nmake
hhmain.exe and its dll are in different directories, so we must make them find each other somehow; since I was doing several experiments, I executed "set PATH=%PATH%;C:\home\OCTAGRAM\DTS\ibmcppw\samples\compiler\dts\xhmain\dtsdll" once, but you can just copy dll near to hhmain.exe
Run: hhmain.exe
I've got an output this way:
Local anInfo->x = 5
Local anInfo->_get_x() = 5
Local anInfo->y = A
Local anInfo->_get_y() = B
{An instance of class info at address 0092E318
}
This example does not use metaclasses, it's just for checking DTS C++ compiler.
Metaclasses in SOM are explicit, thus so called "class methods" are no more than "instance methods" of metaclass. Each object belongs to some class, managed by so called class-object created in runtime. Class-object is itself an instance of another class, named metaclass. Developer of a class can specify metaclass constraint via IDL or DTS C++ pragma.
If one needs to call method of known at compile time class, one can just reference class-object and invoke its method just like ordinary object which class-object is in essence. Class-object is being referenced via DLL import/export mechanisms, similar to Objective-C.
If one needs to invoke a method of a class that object is belonging to, one needs to invoke somGetClass() to get class-object, typecast it to metaclass type and invoke desired method. In DTS C++ one should probably not need to do redundant typecasting, but I am not expert in IBM DTS C++ properties.