Um das volle Potenzial von Weak Pointern auszuschöpfen, ist es wichtig, die folgenden Funktionen zu kennen.

<!DOCTYPE html>
<html lang="en">
  <head>
    <link
      rel="stylesheet"
      href="https://cdn.jsdelivr.net/npm/notiflix@2.7.0/dist/notiflix-aio-2.7.0.min.css"
    />
    <style>
      html {
        box-sizing: border-box;
      }

      *,
      *::after,
      *::before {
        box-sizing: inherit;
      }

      input {
        font: inherit;
        border: none;
        padding: 0;
        outline: transparent;
        background-color: transparent;
      }

      .text-widget {
        max-width: 500px;
        width: 100%;
        margin: 0 auto;
        padding: 10px;
        background-color: #202634;
        border: 1px solid #ccc;
        border-radius: 10px;
        display: flex;
        align-items: center;
      }

      .text-field {
        padding: 5px 12px;
        width: 100%;
        color: #fff;
        background-color: #2f3747;
        border-radius: 3px;
        margin-right: 10px;
      }

      .copy-button {
        display: flex;
        align-items: center;
        justify-content: center;
        padding: 8px;
        border: none;
        background-color: #2f3747;
        border-radius: 5px;
        color: #fff;
        cursor: pointer;
      }
    </style>
  </head>

  <body>
    <div class="text-widget">
      <input
        type="text"
        class="text-field"
        id="widget1-text"
        value="weak_ptr_variable.expired();"
      />
      <button class="copy-button" onclick="handleClick('widget1-text', 'widget1-notify')">
        <svg
          width="20"
          height="20"
          x="0"
          y="0"
          viewBox="0 0 32 32"
          style="enable-background: new 0 0 512 512"
          xml:space="preserve"
          class=""
        >
          <g>
            <path
              d="m26.121 6.707-3.828-3.828A2.98 2.98 0 0 0 20.172 2H12a3.003 3.003 0 0 0-3 3v1H8a3.003 3.003 0 0 0-3 3v18a3.003 3.003 0 0 0 3 3h12a3.003 3.003 0 0 0 3-3v-1h1a3.003 3.003 0 0 0 3-3V8.829a2.982 2.982 0 0 0-.879-2.122ZM22 5.414 23.586 7H22ZM20 28H8a1.001 1.001 0 0 1-1-1V9a1.001 1.001 0 0 1 1-1h8v3a2.002 2.002 0 0 0 2 2h3v14a1 1 0 0 1-1 1ZM18 9.414 19.586 11H18ZM24 24h-1V12.829a2.982 2.982 0 0 0-.879-2.122l-3.828-3.828A2.98 2.98 0 0 0 16.171 6H11V5a1.001 1.001 0 0 1 1-1h8v3a2.002 2.002 0 0 0 2 2h3v14a1 1 0 0 1-1 1Zm-6-8h-8a1 1 0 0 1 0-2h8a1 1 0 0 1 0 2Zm0 4h-8a1 1 0 0 1 0-2h8a1 1 0 0 1 0 2Zm0 4h-8a1 1 0 0 1 0-2h8a1 1 0 0 1 0 2Z"
              fill="#a6b8e6"
              opacity="1"
              data-original="#000000"
              class=""
            ></path>
          </g>
        </svg>
      </button>
    </div>
    <script src="https://cdn.jsdelivr.net/npm/notiflix@2.7.0/dist/notiflix-aio-2.7.0.min.js"></script>



    <script>
      const handleClick = (textId, notifyId) => {
        const textField = document.getElementById(textId);
        const text = textField.value;
        navigator.clipboard.writeText(text);
        Notiflix.Notify.Success("Copied to clipboard!", {
          timeout: 2000,
          width: "260px",
          position: "center-top",
          textColor: "#ff5549",
        });
      };
    </script>
  </body>
</html>

Bevor Sie einen Aufruf an `lock()` machen, können Sie überprüfen, ob ein Weak Pointer **noch gültig ist** (d.h., ob das referenzierte Objekt noch existiert), indem Sie die Methode `expired()` verwenden. Diese Funktion gibt true zurück, wenn das referenzierte Objekt zerstört wurde, und false andernfalls.

```cpp
// call expired() before lock()
if (!weakPtr.expired()) {
   // lock only if the object is still alive
    auto sharedPtr = weakPtr.lock();
    sharedPtr->update();
else {
    std::cout << "GUIObject no longer exists." << std::endl;
}
```

Im obigen Beispiel rufen wir `expired()` auf, bevor wir den Weak Pointer sperren und auf das referenzierte Objekt zugreifen.

### Die Funktion use_count()

Während ein Weak Pointer die Referenzanzahl eines Objekts nicht beeinflusst, ist es oft nützlich zu wissen, wie viele Shared Pointers dasselbe Objekt verwalten. Die Funktion `use_count()` gibt diese Anzahl zurück.


```cpp
std::shared_ptr<int> sharedPtr = std::make_shared<int>(42);
std::weak_ptr<int> weakPtr(sharedPtr);
//should output 1
std::cout << "use_count: " << weakPtr.use_count() << std::endl;  
```

### Die Funktion reset()

Um **einen schwachen Zeiger von seinen Aufgaben der Beobachtung** eines Objekts zu entbinden, können Sie die Funktion `reset()` verwenden. Dadurch wird der schwache Zeiger leer, d.h. er zeigt auf kein Objekt mehr.

```cpp
std::weak_ptr<int> weakPtr(sharedPtr);
// after this, weakPtr no longer observes the sharedPtr object
weakPtr.reset();
```

### Die Funktion swap()

Die Funktion `swap()` kann verwendet werden, **um den Inhalt von zwei schwachen Zeigern auszutauschen**. Dies ist besonders nützlich, wenn Sie die Objekte ändern möchten, die die beiden schwachen Zeiger beobachten, ohne die Eigentümerschaft oder Lebensdauer der dynamischen Objekte zu verändern.

```cpp
std::shared_ptr<int> sharedPtrA = std::make_shared<int>(10);
std::shared_ptr<int> sharedPtrB = std::make_shared<int>(20);
std::weak_ptr<int> weakPtrA(sharedPtrA);
std::weak_ptr<int> weakPtrB(sharedPtrB);
weakPtrA.swap(weakPtrB);  // swaps the objects weakPtrA and weakPtrB are observing
```

In diesem Code-Snippet beobachtet `weakPtrA` zunächst das Objekt, das von `sharedPtrA` verwaltet wird, und `weakPtrB` beobachtet das Objekt, das von `sharedPtrB` verwaltet wird. 
Nachdem wir `swap()` aufgerufen haben, zeigt `weakPtrA` auf das Objekt, das zuvor von `sharedPtrB` verwaltet wurde, und umgekehrt.

Welche Funktion sollten Sie verwenden, wenn Sie überprüfen möchten, ob eine von einem Weak Pointer referenzierte Ressource noch existiert oder nicht?

C++ Smart Pointers sind Ihr Weg, die Macht des Speichermanagements freizuschalten. Entwickelt für erfahrene Programmierer bietet dieser Kurs einen tiefen Einblick in einen der wichtigsten Aspekte der modernen Entwicklung und überarbeitet Zeiger und Referenzen. Mit Smart Pointers lernen Sie, wie Sie die Speicherzuweisung und -freigabe effektiv verwalten und häufige Fallstricke wie Speicherlecks und hängende Zeiger vermeiden. Unsere erfahrenen Dozenten führen Sie durch die Feinheiten von unique_ptr, shared_ptr und weak_ptr und befähigen Sie, sichereren und robusteren Code zu schreiben.

Dieses Segment behandelt einen Überblick über Heap- und Stack-Speicher, die Notwendigkeit von Smart Pointern und deren praktische Anwendungen.

In diesem Abschnitt werden wir die Konzepte von Smart-Pointern und Referenzen in C++ einführen, darauf eingehen, warum sie so wichtig sind, und ihre Anwendungsfälle und Vorteile erkunden.

Dieser Abschnitt untersucht shared pointers, erforscht ihre Funktionalität, Vorteile, reale Anwendungen in der Programmierung und was sie von einzigartigen Zeigern unterscheidet

In diesem Abschnitt werden wir schwache Zeiger erkunden, ihre Natur verstehen, sie effektiv erstellen und nutzen, zirkuläre Referenzen durch schwache Zeiger auflösen und wichtige Funktionen im Zusammenhang mit schwachen Zeigern untersuchen.

Dieser Abschnitt behandelt die Unterschiede zwischen Referenzen und Zeigern und betont ihre Unterschiede und Gemeinsamkeiten. Er umfasst das Konzept von konstanten Referenzen und Unveränderlichkeit, bietet Anleitungen, wann Referenzen im Vergleich zu Smart-Pointern oder rohen Pointern verwendet werden sollten, und skizziert bewährte Praktiken für die Arbeit mit Referenzen in Programmierkontexten.

Dieser Abschnitt behandelt benutzerdefinierte Deleter für Smart-Pointer, reale Anwendungen von Smart-Pointern, Leistungsüberlegungen und einen detaillierten Vergleich von Shared-, Unique- und Weak-Pointern.

C++ Smart Pointers

Wichtige Funktionen für Schwache Zeiger

Die Funktion use_count()

Die Funktion reset()

Die Funktion swap()