🔤 Lesson 1.4: A C++ Refresher, Unreal-Flavored

Values, References & Pointers

Unreal C++ is full of * and &. Getting these straight now saves endless confusion later, because Unreal has strong conventions about which to use.

The three ways to pass and hold data

int32 Health = 100;      // a VALUE: Health owns its own int

int32& RefHealth = Health; // a REFERENCE: another name for Health (no copy, can't be null)
RefHealth = 80;            // this changes Health to 80

int32* PtrHealth = &Health; // a POINTER: holds the address of Health; CAN be null
*PtrHealth = 50;            // "dereference" to reach the value; sets Health to 50
PtrHealth = nullptr;        // pointers can be reseated or nulled

How Unreal uses each

Const Correctness

Unreal code uses const heavily, and reading it fluently is a real skill. const is a promise to the compiler — and to other programmers — that something won't be modified.

// const parameter: this function promises not to change the passed struct
float GetDamageFrom(const FAttackData& Attack);

// const member function: promises not to modify the object it's called on
class AEnemy : public AActor
{
public:
    // The trailing 'const' means: calling GetHealth() won't change this Enemy.
    int32 GetHealth() const { return Health; }

    // No trailing const: this one is allowed to modify the Enemy.
    void TakeDamage(int32 Amount) { Health -= Amount; }

private:
    int32 Health = 100;
};

💡 Read it right-to-left: const FAttackData& is "a reference to a const FAttackData." The const protects the data; the & avoids the copy. That exact combination is the single most common parameter form in the engine.

Headers & Forward Declarations

C++ splits a class across two files, and Unreal follows this rigorously:

The forward-declaration habit

Including a header pulls in everything it includes — do that carelessly and compile times explode. Unreal's answer is the forward declaration: in a header, you often only need to say "this type exists," not include its full definition.

// MyActor.h

// Forward declarations — we only use these as pointers here, so we don't
// need their full headers yet. This keeps compile times down.
class UStaticMeshComponent;
class AEnemy;

#include "GameFramework/Actor.h"
#include "MyActor.generated.h"   // ALWAYS the last include in a UCLASS header

UCLASS()
class MYPROJECT_API AMyActor : public AActor
{
    GENERATED_BODY()

public:
    UPROPERTY(VisibleAnywhere)
    UStaticMeshComponent* Mesh;   // pointer to a forward-declared type: fine

    void ChaseTarget(AEnemy* Target);
};

// MyActor.cpp — here we DO need the full definitions, so we include them
#include "MyActor.h"
#include "Components/StaticMeshComponent.h"  // now we can use its members
#include "Enemy.h"

void AMyActor::ChaseTarget(AEnemy* Target)
{
    if (Target) { /* ... use Target's full API ... */ }
}

Templates & Macros You'll See

You don't need to write templates to use Unreal, but you'll read them constantly. Two syntaxes to be comfortable with:

Templates: angle brackets mean "of what type"

TArray<int32> Scores;        // a dynamic array OF int32
TArray<AActor*> Enemies;      // a dynamic array OF actor pointers
TMap<FName, int32> Inventory; // a map from FName keys TO int32 values

// Cast<T> is a template too — safely converts a base pointer to a derived type,
// returning nullptr if the object isn't actually that type:
AEnemy* AsEnemy = Cast<AEnemy>(SomeActor);
if (AsEnemy) { /* it really was an AEnemy */ }

These are Unreal's own container and utility templates. We cover the containers in Lesson 2.4 and Cast in Module 2 — for now, just read TArray<AActor*> as "array of actor pointers" and move on.

Macros: the CAPS words are code generators

UCLASS()          // marks a class for the reflection system
GENERATED_BODY()  // expands into engine-generated boilerplate
UPROPERTY(...)    // exposes a member variable to the engine/editor
UFUNCTION(...)    // exposes a function to the engine/Blueprint
UE_LOG(...)       // logging

💡 Don't panic at unfamiliar CAPS: when you see an ALL-CAPS token followed by parentheses at class or member scope, it's almost certainly a reflection macro. You'll learn each one in context.

Hands-on Exercise & Quiz

// A
void ApplyDamage(const FDamageEvent& Event, AActor* Instigator);

// B
float GetSpeed() const;

// C
TArray<AActor*> FindEnemiesInRadius(float Radius) const;

Summary

📚 Additional Resources

• Epic C++ Coding Standard (Epic)
• Programming & Scripting overview (Epic)

🚀 What's Next?

Language ready, tools ready. Time for the moment it all pays off: creating your first C++ class in the editor, compiling it, and watching Live Coding turn edits into running behavior in seconds.