This example shows the implementation of state mode in C. 1. Define the State interface class and declare pure virtual functions of play, pause, and stop; 2. Implement the three specific state classes StoppedState, PlayingState, and PausedState, each defining behavior based on the current state; 3. Create an AudioPlayer context class, hold the current state object and delegate the state behavior; 4. Call the play, pause, and stop methods in the main function, and the behavior changes with the internal state change; the final output conforms to the expected state transition, and the state mode is fully implemented to eliminate conditional logic and improve maintainability.

The State Pattern is a behavioral design pattern that allows an object to change its behavior when its internal state changes. In C , this is typically implemented using polymorphism — each state is represented by a separate class, and the context object delegates state-specific behavior to the current state object.

Here's a practical C example of the State Pattern:

? Example: A Simple Audio Player

Imagine an audio player that can be in different states: Stopped , Playing , or Paused . The behavior of actions like play() , pause() , and stop() depends on the current state.

? Step 1: Define the State Interface

 // State.h
#ifndef STATE_H
#define STATE_H

class AudioPlayer; // Forward declaration

class State {
public:
    virtual ~State() = default;
    virtual void play(AudioPlayer* player) = 0;
    virtual void pause(AudioPlayer* player) = 0;
    virtual void stop(AudioPlayer* player) = 0;
};

#endif

? Step 2: Implement Concrete States

 // StoppedState.h
#ifndef STOPPED_STATE_H
#define STOPPED_STATE_H

#include "State.h"

class StoppedState : public State {
public:
    void play(AudioPlayer* player) override;
    void pause(AudioPlayer* player) override;
    void stop(AudioPlayer* player) override;
};

#endif

 // StoppedState.cpp
#include "StoppedState.h"
#include "AudioPlayer.h"
#include <iostream>

void StoppedState::play(AudioPlayer* player) {
    std::cout << "Starting playback.\n";
    player->changeState(new PlayingState());
}

void StoppedState::pause(AudioPlayer* player) {
    std::cout << "Can&#39;t pause — already stopped.\n";
}

void StoppedState::stop(AudioPlayer* player) {
    std::cout << "Already stopped.\n";
}

 // PlayingState.h
#ifndef PLAYING_STATE_H
#define PLAYING_STATE_H

#include "State.h"

class PlayingState : public State {
public:
    void play(AudioPlayer* player) override;
    void pause(AudioPlayer* player) override;
    void stop(AudioPlayer* player) override;
};

#endif

 // PlayingState.cpp
#include "PlayingState.h"
#include "AudioPlayer.h"
#include <iostream>

void PlayingState::play(AudioPlayer* player) {
    std::cout << "Already playing.\n";
}

void PlayingState::pause(AudioPlayer* player) {
    std::cout << "Pausing playback.\n";
    player->changeState(new PausedState());
}

void PlayingState::stop(AudioPlayer* player) {
    std::cout << "Stopping playback.\n";
    player->changeState(new StoppedState());
}

 // PausedState.h
#ifndef PAUSED_STATE_H
#define PAUSED_STATE_H

#include "State.h"

class PausedState : public State {
public:
    void play(AudioPlayer* player) override;
    void pause(AudioPlayer* player) override;
    void stop(AudioPlayer* player) override;
};

#endif

 // PausedState.cpp
#include "PausedState.h"
#include "AudioPlayer.h"
#include <iostream>

void PausedState::play(AudioPlayer* player) {
    std::cout << "Resuming playback.\n";
    player->changeState(new PlayingState());
}

void PausedState::pause(AudioPlayer* player) {
    std::cout << "Already paused.\n";
}

void PausedState::stop(AudioPlayer* player) {
    std::cout << "Stopping playback.\n";
    player->changeState(new StoppedState());
}

? Step 3: Context Class (AudioPlayer)

 // AudioPlayer.h
#ifndef AUDIO_PLAYER_H
#define AUDIO_PLAYER_H

#include "State.h"

class AudioPlayer {
private:
    State* currentState;

    // Helper to delete old state
    void changeState(State* newState) {
        delete currentState;
        currentState = newState;
    }

public:
    AudioPlayer();
    ~AudioPlayer();

    void play();
    void pause();
    void stop();

    // For testing: get current state type (optional)
    std::string getStateName() const;
};

#endif

 // AudioPlayer.cpp
#include "AudioPlayer.h"
#include "StoppedState.h"
#include <typeinfo>

AudioPlayer::AudioPlayer() {
    currentState = new StoppedState(); // Initial state
}

AudioPlayer::~AudioPlayer() {
    delete currentState;
}

void AudioPlayer::play() {
    currentState->play(this);
}

void AudioPlayer::pause() {
    currentState->pause(this);
}

void AudioPlayer::stop() {
    currentState->stop(this);
}

std::string AudioPlayer::getStateName() const {
    if (dynamic_cast<const StoppedState*>(currentState))
        return "Stopped";
    else if (dynamic_cast<const PlayingState*>(currentState))
        return "Playing";
    else if (dynamic_cast<const PausedState*>(currentState))
        return "Paused";
    return "Unknown";
}

? Step 4: Usage Example

 // main.cpp
#include "AudioPlayer.h"
#include <iostream>

int main() {
    AudioPlayer player;

    player.play(); // Output: Starting playback.
    player.pause(); // Output: Pausing playback.
    player.play(); // Output: Resuming playback.
    player.stop(); // Output: Stopping playback.
    player.pause(); // Output: Can&#39;t pause — already stopped.

    return 0;
}

? Output

 Starting playback.
Pausing playback.
Resuming playback.
Stopping playback.
Can't pause — already stopped.

? Key Points

• The context ( AudioPlayer ) delegates state-specific behavior to the current State object.
• Each concrete state handles transitions and behavior independently.
• The changeState() method safely deletes the old state and switches to a new one.
• You avoid messy if/else or switch statements based on state variables.

?? Notes

• This example uses raw points and new/delete . In production, consider using smart points (eg, std::unique_ptr ) for better memory safety.
• The AudioPlayer owns its state, so it handles deletion properly.
• States are created on the heap — fine for small examples, but pooling or flyweight patterns can optimize in performance-critical cases.

That's a clean, working C implementation of the State Pattern . It's especially useful when you have complex state-dependent logic that would otherwise become unmanageable with conditions.

Basically just organize your states, let them handle their own rules, and let the context delegate.

The above is the detailed content of C state pattern example. For more information, please follow other related articles on the PHP Chinese website!