Why does sizeof(array) return three times more than indexes in the array?

The expression with the sizeof operator sizeof(A) yields the size in bytes of the array A. The obtained value is equal to the number of elements in the array multiplied by the size of element of the array that is

sizeof( A ) = 8 * sizeof( int )

So if you have an array size and know the type of elements of the array you can get the number of elements in the array like

size_t n = sizeof( A ) / sizeof( A[0] )

It means that your for loop should be rewritten like

for ( size_t i = 0, n = sizeof( A ) / sizeof( A[0] ); i < n; i++ ) {
//...

From the C++17 Standard (8.3.3 Sizeof)

1 The sizeof operator yields the number of bytes in the object representation of its operand. The operand is either an expression, which is an unevaluated operand (Clause 8), or a parenthesized type-id. The sizeof operator shall not be applied to an expression that has function or incomplete type, to the parenthesized name of such types, or to a glvalue that designates a bit-field. sizeof(char), sizeof(signed char) and sizeof(unsigned char) are 1. The result of sizeof applied to any other fundamental type (6.9.1) is implementation-defined. [ Note: In particular, sizeof(bool), sizeof(char16_t), sizeof(char32_t), and sizeof(wchar_t) are implementation-defined.

Pay attention to that there is standard C++ function std::size() declared in header <iterator> that can be use instead of the expression with the sizeof operator

#include <iterator>

//...

for ( size_t i = 0, n = std::size( A ); i < n; i++ ) {
//...

But before intriducing the standard C++ function std::size there was used data member value if structure std::extent declared in header <type_traits>.

Another approach is to use range-based for loop like

for ( const auto &item : A ) {
        cout << item << endl;
}

Also you could use iterators in the for loop or a standard algorithm like std::copy. or std::for_each.

Here is a demonstration program that shows possible ways to output an array

#include <iostream>
#include <type_traits>
#include <iterator>
#include <algorithm>

int main()
{
    int A[] = { 1, 2, 4, 8, 16, 32, 64, 128 };

    //  using the sizeof operator
    for (size_t i = 0, n = sizeof( A ) / sizeof( A[0] ); i < n; i++)
    {
        std::cout << A[i] << ' ';
    }
    std::cout << '\n';

    //  using function std::size()
    for (size_t i = 0, n = std::size( A ); i < n; i++)
    {
        std::cout << A[i] << ' ';
    }
    std::cout << '\n';

    //  using std::extent_v
    for (size_t i = 0, n = std::extent_v<decltype( A )>; i < n; i++)
    {
        std::cout << A[i] << ' ';
    }
    std::cout << '\n';

    //  using range-based for loop
    for ( const auto &item : A )
    {
        std::cout << item << ' ';
    }
    std::cout << '\n';

    //  using for loop with iterators
    for (auto first = std::begin( A ), last = std::end( A ); first != last; ++first)
    {
        std::cout << *first << ' ';
    }
    std::cout << '\n';

    //  using algorithm std::copy
    std::copy( std::begin( A ), std::end( A ),
        std::ostream_iterator<int>( std::cout, " "));
    std::cout << '\n';

    //  using algorithm std::for_each
    std::for_each( std::begin( A ), std::end( A ),
        []( const auto &item )
        {
            std::cout << item << ' ';
        } );
    std::cout << '\n';

}

The program output is

1 2 4 8 16 32 64 128 
1 2 4 8 16 32 64 128 
1 2 4 8 16 32 64 128 
1 2 4 8 16 32 64 128 
1 2 4 8 16 32 64 128 
1 2 4 8 16 32 64 128 
1 2 4 8 16 32 64 128