C++ practice

June 26, 2018

I try to collect C++ syntax while I am practicing Unreal C++ implementation.

Class: class is a custom datatype. It could be a data or a function.
Pointer: pointer is an address of a variable, but why do you need pointer? and how do you use it?

#include <iostream>

int main()
{
    int num = 342;
    std::cout<<"num = "<<num<<"\n";
    std::cout<<"address of num is at &num = "<< &num<<"\n";
    return 0;
}

num = 342
address of num is at &num = 0x7ffd2a738f6c

Dereferencing: if you want to refer to the value based on the address, it’s called dereferencing.

#include <iostream>
int main()
{
    int num = 32;
    int * pointerTonum = &num;
    std::cout<<"pointerTonum stores the address of num as"<< pointerTonum<<endl;
    std::cout<<"the address of PointerTonum stores the value of num as<< *pointerTonum<<endl;
}

To access a member in a class, use ->. For instance, foo->bar means *foo.bar.
To access a function in a class, use ::.
Constructor is used to set the intial value of the class. i.e. ClassName::ClassName()
#pragma once is to cause the current source file to be included only once in a single compilation.
a class (A) after :(single colon) from another class (B) means, B is the inherited class from A. Here is an example from Unreal source code:

class ENGINE_API USphereComponent : public UShapeComponent
{
    // code
}

Overloading: C++ allows the same function name could be used for multiple implementation. Here is an example code:

#include <iostream>
using namespace std;
class printNum{
    public:
        void print(int i){
            cout<<"print integer: "<< i <<endl;
        }
        void print(double f){
            cout<<"print float: "<< f <<endl;
        }
        void print(char*c){
            cout<<"print character: "<< c <<endl;
        }

}

int main()
{
    printNum pn;

    // print integer
    pn.print(23);
    // print float
    pn.print(234.23);
    // print character
    pn.print("hello C++");

    return 0;
}

Template: it allows a function or class to work on many different data types without being rewritten for each one. For instance, foo<T> is a template and T is the template parameter.

void AFPSObjectiveActor::NotifyActorBeginOverlap(AActor* OtherActor)
{
	Super::NotifyActorBeginOverlap(OtherActor);
	PlayEffects();

	AFPSCharacter* MyCharacter = Cast<AFPSCharacter>(OtherActor);
	if (MyCharacter)
	{
		MyCharacter->bIsCarryingObjective = true;
	}

}

Forward declaration: If the member variable is a pointer, class definition in the header file is not needed. The reason is pointers are only addresses.

class UBoxComponent; // forward declaration
class FPSGAME_API AFPSExtractionZone : Public AActor
{
protected:
	UBoxComponent* OverlapComp;
}

Casting: It’s an operator which forces a data type to be converted into another.

#include <iostream>
using namespace std;
int main()
{
	float f = 5.4;
	int a = static_cast<int>(f);
	cout <<a;
}

Reference vs. pointer (1)

	Pointers	References
what is stored	memory address	memory address
can be re-assigned	Yes	No
Can be null	Yes (use nullptr)	No, must be initialized
Accessing contents	* ActorPtr	ActorRef
Accessing address	ActorPtr	&ActorRef
Changing the address	ActorPtr = &Actor	Not allowed
Changing the value	* ActorPtr = Actor	ActorRef = Actor

Reference vs. pointer (2)

Lefthand side item	Accessor	Examples	Remark
Instance or reference	.	mygrab.grab()	access to member function (grab()) of mygrab class
pointer	->	mybrabptr->grab()
class enum.namespace	::	ugrabber::grb

Reference