Count the frequencies of each word in a file

Kudos on writing a working program! You already sense that things can be improved, which is also great. Toby Speight already pointed out some issues in your code. You are a beginning C++ programmer, so it's normal that you don't write optimal code yet; you have just learned the basic tools. To show you how a more experienced C++ programmer would tackle the problem of counting frequencies, let me show you this implementation:

#include <cstdlib>
#include <algorithm>
#include <format>
#include <fstream>
#include <iostream>
#include <ranges>
#include <unordered_map>
#include <vector>

// A struct to hold a value and its frequency
template<typename T>
struct counted_value {
    std::size_t count;
    T value;

    // Add a default comparison operator so we can sort on these structs
    friend auto operator<=>(const counted_value&, const counted_value&) = default;
};

// A templated function that can take any kind of input
template<std::ranges::input_range Range>
auto count_frequencies(Range&& range) {
    // Deduce the type of values stored in the range
    using value_type = decltype(std::ranges::begin(range))::value_type;

    // Count frequencies in a hash map
    std::unordered_map<value_type, std::size_t> counters;

    for (const auto& value: range) {
        counters[value]++;
    }

    // Copy the result into a vector
    std::vector<counted_value<value_type>> result;
    result.reserve(counters.size());

    for (const auto& [value, count]: counters) {
        result.emplace_back(count, value);
    }

    // Sort the vector on the frequency count, largest count first
    std::ranges::sort(result, std::greater{});

    return result;
}

int main() {
    std::ifstream input("words.txt");

    // Create a view of the words in the input stream
    auto words = std::ranges::istream_view<std::string>(input);

    auto frequencies = count_frequencies(words);

    // We should have reached the end, if we didn't something went wrong
    if (!input.eof()) {
        std::cerr << "Error reading input\n";
        return EXIT_FAILURE;
    }

    for (const auto& item: frequencies) {
        std::cout << std::format("Frequency for word {}: {}\n",
                                 item.value, item.count);
    }
}

I've used a lot of features from the standard library and from the language itself, in particular features from C++20. I'll list them here with links to cppreference.com:

• template so you can create a frequency counting function that can count any kind of input, not just an array of strings.
• A default comparison operator to make a struct comparable, which helps it sort later.
• The concept std::ranges::input_range to restrict the input of count_frequencies() to ranges that can be iterated over. It's not really necessary here, but it results in nicer error messages if you call the function with the wrong type of input.
• using to declare a type alias, this is just to save typing.
• decltype() to deduce the type of values stored in the input range.
• std::unordered_map is basically a dictionary, we use it to count how often a given value appears in the input.
• Range-based for loops, this is often simpler and safer than the old for loops where you manually iterate.
• std::vector is basically a dynamically sized array. It takes care of memory allocation for you. We use it to store the final result.
• std::ranges::sort() provides an easy way to sort containers. Normally it sorts so the smallest value comes first, but we pass it std::greater so we sort it largest value first.
• The auto type lets the compiler deduce the type for you. This saves typing and reduces the chance of making mistakes.
• std::ranges::istream_view() is a helper that allows you to convert an input stream (like the file you open) into a view that can be iterated over using range-based for loops and with other algorithms.
• std::format() makes it much easier to format strings. C++23 also introduced std::print() which makes it even easier to print things, but not all compilers support it yet.

Don't worry about all of this, just continue your programming journey, and eventually you learn most or all of the above.