🚀 Lesson 1.5: Your First C++ Class & the Live Coding Loop

Creating the Class

Unreal generates the boilerplate for you. In the editor:

1. Open Tools → New C++ Class…
2. Choose Actor as the parent class, click Next
3. Name it SpinningCube, confirm the module, and click Create Class

Unreal creates SpinningCube.h and SpinningCube.cpp in your Source/ tree, adds them to the build, and compiles. The class name becomes ASpinningCube — the A prefix marks it as an actor (a convention enforced by the header tool; more on prefixes in Lesson 2.1).

Anatomy of the Generated Files

Here's what the wizard produces, annotated line by line. First the header:

// SpinningCube.h
#pragma once                       // include guard — appears once per header

#include "CoreMinimal.h"           // the lightweight base include for most headers
#include "GameFramework/Actor.h"   // we derive from AActor, so we need its header
#include "SpinningCube.generated.h" // MUST be last — generated reflection code

UCLASS()                           // reflection macro: register this class
class MYPROJECT_API ASpinningCube : public AActor
{
    GENERATED_BODY()               // expands to engine boilerplate for this class

public:
    ASpinningCube();               // constructor: set defaults, create components

protected:
    virtual void BeginPlay() override;   // called once when play starts

public:
    virtual void Tick(float DeltaTime) override;  // called every frame
};

Now the source file:

// SpinningCube.cpp
#include "SpinningCube.h"

// Constructor: runs when the object is created (in editor AND at runtime).
ASpinningCube::ASpinningCube()
{
    // Tell the engine this actor wants Tick() called every frame.
    // (It's off by default for performance — you opt in.)
    PrimaryActorTick.bCanEverTick = true;
}

// Called once, when the game starts or the actor is spawned into a running level.
void ASpinningCube::BeginPlay()
{
    Super::BeginPlay();   // ALWAYS call the base version first
}

// Called every frame; DeltaTime is seconds since the last frame.
void ASpinningCube::Tick(float DeltaTime)
{
    Super::Tick(DeltaTime);   // ALWAYS call the base version
}

Making It Do Something

Let's give the cube a visible mesh, an exposed rotation-speed property, a startup log, and per-frame rotation. This touches everything from Module 1 at once. The header first:

// SpinningCube.h
#pragma once

#include "CoreMinimal.h"
#include "GameFramework/Actor.h"
#include "SpinningCube.generated.h"

class UStaticMeshComponent;   // forward declaration — we only hold a pointer here

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

public:
    ASpinningCube();

protected:
    virtual void BeginPlay() override;

public:
    virtual void Tick(float DeltaTime) override;

    // The visible cube. VisibleAnywhere: shown but not reassignable in Details.
    UPROPERTY(VisibleAnywhere, Category = "Spinning Cube")
    UStaticMeshComponent* Mesh;

    // Degrees per second. EditAnywhere + BlueprintReadWrite so designers and
    // Blueprint subclasses can tune it. This appears in the Details panel.
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Spinning Cube")
    float RotationSpeed = 90.0f;
};

Now the implementation:

// SpinningCube.cpp
#include "SpinningCube.h"
#include "Components/StaticMeshComponent.h"   // full header — we call its members

ASpinningCube::ASpinningCube()
{
    PrimaryActorTick.bCanEverTick = true;

    // Create the mesh component and make it this actor's root.
    // CreateDefaultSubobject is the constructor-only way to build components.
    Mesh = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("Mesh"));
    RootComponent = Mesh;
}

void ASpinningCube::BeginPlay()
{
    Super::BeginPlay();

    // Our first real log: %s prints an FString; the leading * converts
    // GetName()'s FString to the raw characters the format expects.
    UE_LOG(LogTemp, Warning, TEXT("%s is ready to spin at %.1f deg/s"),
        *GetName(), RotationSpeed);
}

void ASpinningCube::Tick(float DeltaTime)
{
    Super::Tick(DeltaTime);

    // Frame-rate independent rotation: multiplying by DeltaTime means the cube
    // spins RotationSpeed degrees PER SECOND regardless of frame rate.
    AddActorLocalRotation(FRotator(0.0f, RotationSpeed * DeltaTime, 0.0f));
}

Place, Compile, Play

With the code written:

1. Compile — press the Compile button in the editor toolbar (or build from your IDE). This triggers Live Coding (next section).
2. Assign a mesh — drag ASpinningCube from C++ Classes into the level, select it, and in the Details panel set the mesh component's Static Mesh to the engine's Cube (or make a Blueprint subclass with the mesh pre-set — the Module 6 way).
3. Press Play — the cube spins, and the Output Log shows your "…is ready to spin at 90.0 deg/s" line.
4. Tune it live — while stopped, change RotationSpeed in Details to 360 and play again. No recompile needed, because the value is data, not code.

💡 Data vs code: changing a UPROPERTY value in Details is instant — it's data on an instance. Changing the logic in .cpp requires a compile. Knowing which kind of change you're making tells you whether you need Live Coding.

The Live Coding Loop

Live Coding lets you recompile C++ and patch it into the running editor — no restart. It's the feature that makes C++ iteration bearable. The loop:

What Live Coding handles well

• Changes to function bodies — new logic inside Tick, BeginPlay, your own methods
• Adjusting calculations, adding logs, fixing behavior

What needs a full rebuild (close editor, build, reopen)

• Adding or removing member variables or UPROPERTY declarations (changes the object's memory layout)
• Adding or removing classes, changing a class's parent, or editing headers structurally
• Changing reflection macros (new UFUNCTION, changed specifiers)

Hands-on Exercise & Quiz

// Add a member: float RunningTime = 0.0f;  (in the header — needs a rebuild)
RunningTime += DeltaTime;
const float Offset = FMath::Sin(RunningTime) * BobHeight * DeltaTime;
AddActorLocalOffset(FVector(0.0f, 0.0f, Offset));

Summary

📚 Additional Resources

• Live Coding (Epic)
• Unreal Engine C++ Quick Start (Epic)

🚀 What's Next?

You've shipped your first working C++ actor — congratulations, that's the hardest first step. Module 2 goes under the hood: the reflection system that made UCLASS and UPROPERTY work, Unreal's own types and containers, and the memory model that explains why we never use plain new.