<!DOCTYPE html>
<html>
<head>
    <link rel="stylesheet" href="https://cdn.plyr.io/3.6.8/plyr.css" />
    <style>
        #custom-player .plyr--video .plyr__controls {
            background-color: #1e2635;
            padding-bottom: 15px;
            padding-top: 15px;
        }

        #custom-player .plyr__control {
            color: #9bbaee;
        }

        #custom-player .plyr__control:hover,
        #custom-player .plyr--video .plyr__control[aria-expanded="true"] {
            color: #ff8a00;
        }

        #custom-player .plyr__progress--played {
            background-color: #4f5e77;
        }

        #custom-player .plyr__progress--buffer {
            background-color: #36445c;
        }

        #custom-player .plyr__volume--display {
            color: #ff8a00;
        }

        #custom-player .plyr__control.plyr__tab-focus,
        #custom-player .plyr__control[aria-expanded="true"] {
            background-color: #f4f4f4;
            color: #323232;
        }

        #custom-player .plyr__menu__value[data-value="0.5"] {
            color: #9bbaee;
        }
        #custom-player .plyr__controls .plyr__controls__item.plyr__time {
            font-size: 16px;
            font-family: "Hind Siliguri", sans-serif;
        }
        #custom-player .plyr__menu__container .plyr__control > span {
            font-family: "Hind Siliguri", sans-serif;
            align-items: inherit;
            display: flex;
            width: 100%;
            color: #36445c;
            font-size: 16px;
        }
        #custom-player .plyr__control--overlaid svg {
            left: 5px;
            position: relative;
            fill: #ff8a00;
            width: 40px;
            height: 40px;
            margin: 10px;
        }
        #custom-player .plyr__progress .plyr__tooltip {
            font-size: 16px;
            font-family: "Hind Siliguri", sans-serif;
        }
        #custom-player .plyr__progress input[type="range"] {
            cursor: pointer;
        }
        #transcript {
            margin-top: 20px;
            padding: 10px;
            line-height: 1.5;
        }
        .highlight {
            background-color: #ff8a00;
            color: white;
            font-weight: 600;
            padding: 5px;
        }
        .my-hidden {
            display: none;
        }
        .show-transcript-btn {
            margin-top: 30px;
            background-color: #ff8a00;
            font-family: inherit;
            font-size: 18px;
            font-weight: 600;
            color: white;
            border-radius: 20px;
            padding: 7px 14px;
            cursor: pointer;
            border: none;
            transition: 0.5s ease-in-out;
        }
        .show-transcript-btn:hover {
            background-color: #d27204;
        }
    </style>
</head>
<body>
<div id="custom-player">
    <video width="100%" controls>
        <source
                src="https://codefinity-content-media.s3.eu-west-1.amazonaws.com/23515a83-24c1-4300-93aa-17f6fc71455f/StringMem.mp4"
                type="video/mp4"
                data-plyr-config='{
          "quality": {
            "default": "720",
            "options": ["144", "240", "360", "480", "720", "1080"]
          }
        }'
        />
    </video>
</div>
<button class="show-transcript-btn js-show-transcript-btn">
    Show Transcript
</button>
<div id="transcript" class="my-hidden"></div>

<script src="https://cdn.plyr.io/3.6.8/plyr.js"></script>
<script>
    const showTranscriptBtn = document.querySelector(
        ".js-show-transcript-btn"
    );
    showTranscriptBtn.addEventListener("click", handleClick);

    function handleClick() {
        const transcriptElement = document.getElementById("transcript");
        transcriptElement.classList.toggle("my-hidden");

        if (transcriptElement.classList.contains("my-hidden")) {
            showTranscriptBtn.textContent = "Show Transcript";
        } else {
            showTranscriptBtn.textContent = "Hide Transcript";
        }
    }

    const player = new Plyr("#custom-player video", {
        controls: [
            "play-large",
            "play",
            "progress",
            "current-time",
            "mute",
            "volume",
            "captions",
            "settings",
            "fullscreen",
        ],
        volume: 0.5,
        muted: false,
        settings: ["captions", "quality", "speed"],
        captions: {
            active: true,
            language: "en",
        },
        fullscreen: {
            enabled: true,
            fallback: true,
            iosNative: true,
        },
        speed: {
            selected: 1,
            options: [0.5, 1, 1.5, 2],
        },
        quality: {
            default: "720",
            options: ["144", "240", "360", "480", "720", "1080"],
        },
    });

    player.on("qualitychange", (event) => {
        console.log(`Quality changed to ${event.quality}`);
    });

    player.on("ratechange", (event) => {
        console.log(`Speed changed to ${event.detail.plyr.speed}`);
    });

    const transcriptData = [
        {
            start: 0,
            end: 3,
            text: "Let's figure out how strings are stored in memory.",
        },
        {
            start: 4,
            end: 10,
            text: "In the case of arrays, all the elements are sequentially stored in their own cells in memory.",
        },
        {
            start: 11,
            end: 20,
            text: "However, strings are more than just arrays. They also have additional methods, one of which is .append().",
        },
        {
            start: 20,
            end: 26,
            text: "Arrays have a fixed size. So you can't just add new elements to an array.",
        },
        {
            start: 27,
            end: 40,
            text: "To do so, you need to allocate new space of a larger size, copy the array's content and add new elements there. This process needs to be repeated each time you extend an array.",
        },
        {
            start: 43,
            end: 50,
            text: "Strings work differently. When you append to a string, it allocates some extra space.",
        },
        {
            start: 51,
            end: 55,
            text: "As a result, new characters can be added without reallocation.",
        },
        {
            start: 55,
            end: 60,
            text: "And once we run out of space again, the string doubles its allocated space.",
        },
        {
            start: 61,
            end: 66,
            text: "This way, strings rarely perform the costly operation of reallocation.",
        },
        {
            start: 67,
            end: 75,
            text: "The total space taken by a string is called capacity, and the number of characters is referred to as the length or size. ",
        },
        {
            start: 76,
            end: 81,
            text: "As you will see later in the chapter, several methods exist to work with capacity.",
        },
        // Add more transcript segments as needed
    ];

    const transcriptElement = document.getElementById("transcript");

    function updateTranscript(currentTime) {
        // Clear previous transcript highlighting
        transcriptElement.querySelectorAll("p").forEach((p) => {
            p.classList.remove("highlight");
        });

        // Find the current segment based on the current time
        const currentSegment = transcriptData.find(
            (segment) =>
                currentTime >= segment.start && currentTime <= segment.end
        );

        // Highlight the current segment's text
        if (currentSegment) {
            const currentSegmentElement = transcriptElement.querySelector(
                `p[data-start="${currentSegment.start}"][data-end="${currentSegment.end}"]`
            );
            if (currentSegmentElement) {
                currentSegmentElement.classList.add("highlight");
            }
        }
    }

    player.on("timeupdate", (event) => {
        const currentTime = event.detail.plyr.currentTime;
        updateTranscript(currentTime);
    });

    const transcriptHTML = transcriptData
        .map(
            (segment) =>
                `<p data-start="${segment.start}" data-end="${segment.end}">${segment.text}</p>`
        )
        .join("");

    transcriptElement.innerHTML = transcriptHTML;
</script>
</body>
</html>

As shown in the video, strings have **length** and **capacity**.
They can be accessed using `.length()` and `.capacity()` methods.

I2luY2x1ZGUgPGlvc3RyZWFtPgoKaW50IG1haW4oKQp7CiAgICBzdGQ6OnN0cmluZyBzdHIgPSAiU3RyaW5nIG9mIDIzIGNoYXJhY3RlcnMiOwogICAgc3RkOjpjb3V0IDw8ICJTdHJpbmc6ICIgPDwgc3RyIDw8IHN0ZDo6ZW5kbDs7CiAgICBzdGQ6OmNvdXQgPDwgIkxlbmd0aDoiIDw8IHN0ci5sZW5ndGgoKSA8PCAiIENhcGFjaXR5OiIgPDwgc3RyLmNhcGFjaXR5KCkgPDwgc3RkOjplbmRsOwoKICAgIHN0ci5hcHBlbmQoIi4uLk5vdyAzMiIpOwoKICAgIHN0ZDo6Y291dCA8PCAiLS0tXG5TdHJpbmc6ICIgPDwgc3RyIDw8IHN0ZDo6ZW5kbDs7CiAgICBzdGQ6OmNvdXQgPDwgIkxlbmd0aDoiIDw8IHN0ci5sZW5ndGgoKSA8PCAiIENhcGFjaXR5OiIgPDwgc3RyLmNhcGFjaXR5KCkgPDwgc3RkOjplbmRsOzsKfQ==

There are also two methods to work with capacity, `.reserve(n)` and `shrink_to_fit()`.

- `.reserve(n)` – set capacity to at least `n`;
- `.shrink_to_fit()` – set capacity the same as the length.

So the `.shrink_to_fit()` is useful when you know you will not extend your string, but the capacity is greater than the length. And you can use `.reserve(n)` if your string is likely to be appended multiple times.

I2luY2x1ZGUgPGlvc3RyZWFtPgoKaW50IG1haW4oKQp7CiAgICBzdGQ6OnN0cmluZyBzdHIgPSAiU3RyaW5nIG9mIDIzIGNoYXJhY3RlcnMiOwogICAgc3RkOjpjb3V0IDw8ICJCZWZvcmUgcmVzZXJ2ZTpcbkxlbmd0aDoiIDw8IHN0ci5sZW5ndGgoKSA8PCAiIENhcGFjaXR5OiIgPDwgc3RyLmNhcGFjaXR5KCkgPDwgc3RkOjplbmRsOwogIAogICAgc3RyLnJlc2VydmUoNjApOwogICAgc3RkOjpjb3V0IDw8ICJBZnRlciByZXNlcnZlOlxuTGVuZ3RoOiIgPDwgc3RyLmxlbmd0aCgpIDw8ICIgQ2FwYWNpdHk6IiA8PCBzdHIuY2FwYWNpdHkoKSA8PCBzdGQ6OmVuZGw7CiAgCiAgICBzdHIuc2hyaW5rX3RvX2ZpdCgpOyAgCiAgICBzdGQ6OmNvdXQgPDwgIkFmdGVyIHNocmluazpcbkxlbmd0aDoiIDw8IHN0ci5sZW5ndGgoKSA8PCAiIENhcGFjaXR5OiIgPDwgc3RyLmNhcGFjaXR5KCkgPDwgc3RkOjplbmRsOwp9

Developing a comprehensive understanding of data types is crucial when learning a programming language. This course offers an opportunity to delve deeper into data types in C++, gaining insights into how they are stored in memory. Additionally, the course covers the topic of type conversion.

This section provides a foundational overview of arithmetic operations and their pitfalls, data types, and the importance of specifying types.

short, int, long, float, double, etc. are all numerical data types in C++. In this section, you will learn about all of them as well as the pitfalls they may conceal.

This section will guide you on char and string data types to work with text in C++. You will learn many handy string methods to make using strings easier.

This section focuses on the bool data type, the use of void and auto, and covers type conversion, which is frequently used in C++.

C++ Data Types

Strings in Memory