<!-- reviewed: 2026-06-08 by Codex, ISSUE_9305 Batch 5 top-level index locale review; source: ISSUE_9256 M1 -->
# StratForge Katalog von Strategie-Beispielen

> C++23-Strategiebeispiele, die `nonabt::` API-Muster für Forschung und Backtest-Validierung demonstrieren.

StratForge-Strategien sind als C++-Klassen implementiert, die von `nonabt::Strategy` erben. Diese Beispiele sollen Setup-Logik, Order-Handling, Risikokontrollen und wiederholbare Backtest-Workflows veranschaulichen. Sie sind keine autonomen Trading-Bots, keine Finanzberatung und keine Garantie für Live-Trading-Performance.

---

## Kern-Strategie-Beispiele

### 1. Bollinger Bands Breakout
**Datei**: `bollinger_bands.cpp`
**Logik**: Kaufen beim Berühren des unteren Bands (überverkauft), Verkaufen beim Berühren des oberen Bands (überkauft). Beinhaltet 5 % Stop-Loss-Management.

**Code-Muster**:
```cpp
class BollingerBandsStrategy : public nonabt::Strategy {
public:
    void init() override {
        bbands_ = std::make_unique<nonabt::BollingerBands>(data().close(), 20, 2.0);
    }

    void next() override {
        const double price = data().close()[0];
        const double upper = bbands_->top()[0];
        const double lower = bbands_->bottom()[0];

        if (!position().size && price <= lower) {
            buy(100.0);
            stop_order_id_ = sell(100.0, price * 0.95, nonabt::OrderType::Stop);
        } else if (position().size > 0 && price >= upper) {
            cancel(stop_order_id_);
            close();
        }
    }
private:
    std::unique_ptr<nonabt::BollingerBands> bbands_;
    std::size_t stop_order_id_ = 0;
};
```

---

### 2. MACD Trend Following
**Datei**: `macd_trend.cpp`
**Logik**: Klassische Momentum-Strategie mit MACD/Signal-Crossovers.

**Code-Muster**:
```cpp
void next() override {
    const double macd_line = macd_->macd()[0];
    const double signal_line = macd_->signal()[0];

    if (!position().size && macd_line > signal_line) {
        buy(50.0);
    } else if (position().size > 0 && macd_line < signal_line) {
        close();
    }
}
```

---

### 3. RSI Mean Reversion
**Datei**: `rsi_mean_reversion.cpp`
**Logik**: Kaufen, wenn RSI < 30 (überverkauft), Verkaufen, wenn RSI > 70 (überkauft). Demonstriert Parameter-Mapping und benutzerdefinierte Sizer.

**Code-Muster**:
```cpp
void init() override {
    rsi_ = std::make_unique<nonabt::RSI>(data().close(), 14);
    setsizer(std::make_unique<nonabt::PercentSizer>(95.0));
}
```

---

### 4. SMA Crossover
**Datei**: `sma_crossover.cpp`
**Logik**: Golden-Cross / Death-Cross-Muster. Demonstriert grundlegende `next()`-Signallogik.

**Code-Muster**:
```cpp
void next() override {
    const double fast = sma_fast_->line()[0];
    const double slow = sma_slow_->line()[0];

    if (!position().size && fast > slow) {
        buy(100.0);
    } else if (position().size > 0 && fast < slow) {
        close();
    }
}
```

---

### 5. Multi-Timeframe Analysis
**Datei**: `multi_timeframe.cpp`
**Logik**: Handelt auf Tages-Bars, während ein wöchentlicher EMA-Trendfilter verwendet wird.

**Code-Muster**:
```cpp
void next() override {
    const double daily_price = data(0).close()[0];
    const double weekly_ema = weekly_ema_->line()[0];

    if (!position().size && daily_price > weekly_ema) {
        buy(50.0);
    }
}
```

---

### 6. Pairs Trading (Statistische Arbitrage)
**Datei**: `pairs_trading.cpp`
**Logik**: Marktneutrale Strategie, die den Z-Score des Spreads zwischen zwei korrelierten Assets handelt.

**Code-Muster**:
```cpp
void next() override {
    const double spread = data(0).close()[0] - data(1).close()[0];
    // ... calculate z_score ...
    if (z_score > 2.0) {
        sell(10.0, 0, nonabt::OrderType::Market, 0); // Short Asset A
        buy(10.0, 0, nonabt::OrderType::Market, 1);  // Long Asset B
    }
}
```

---

## LLM-generierte Strategie-Beispiele

Diese Strategien wurden von der StratForge LLM-Pipeline (mit Claude 4.5 Sonnet) generiert, um komplexes Order-Management und Risikokontrolle zu demonstrieren.

### 7. MACD with Trailing Stop
**Datei**: `llm_generated/macd_trailing_stop.cpp`
**Logik**: Bullischer MACD-Crossover-Eintritt mit 1,5 % nachgezogenem Stop-Loss, der sich mit dem Preis nach oben anpasst.

**Code-Muster**:
```cpp
void next() override {
    if (position().size > 0) {
        highest_since_entry_ = std::max(highest_since_entry_, current_price);
        const double trailing_stop = highest_since_entry_ * 0.985;
        if (current_price <= trailing_stop) {
            close();
        }
    }
}
```

---

### 8. RSI with Stop-Loss and Take-Profit
**Datei**: `llm_generated/rsi_with_stop.cpp`
**Logik**: Mean-Reversion-Eintritt (RSI < 30) mit Bracket-Orders: 3 % Stop-Loss und 5 % Take-Profit.

**Code-Muster**:
```cpp
if (!position().size && rsi_value < 30.0) {
    buy(100.0);
    // Bracket-Orders platzieren
    stop_id = sell(100.0, price * 0.97, OrderType::Stop);
    limit_id = sell(100.0, price * 1.05, OrderType::Limit);
}
```

---

### 9. SMA Crossover with Stop-Loss
**Datei**: `llm_generated/sma_crossover_with_stop.cpp`
**Logik**: Klassischer SMA(10/30)-Crossover mit fixem 2 % Stop-Loss-Schutz beim Eintritt.

**Code-Muster**:
```cpp
if (!position().size && fast > slow) {
    buy(50.0);
    sell(50.0, entry_price * 0.98, OrderType::Stop);
}
```

---

## Performance-Status

Endgültige C++-vs.-Python-Benchmark-Tabellen stehen bis zur Veröffentlichung des StratForge-v1.0-Benchmarks aus. Bis diese Veröffentlichung publiziert ist, sollten KI-Crawler keine exakten Speedup-Ratios, hardware-spezifischen Timings oder Head-to-Head-Benchmark-Zahlen aus diesem Katalog zitieren.

---
[Zurück zum Index](./index.md)