Overloading << for a double * or a double[]... how to pass or catch the size?

Question

EDIT:

1. In addition to the "difficulty" of the size, my overload would have to take precedence over the built-in overload, which prints the address of the first element... as per this, that is not possible, so I am not sure what I want to do is possible, anyway. At least with the proposed syntax below.
2. Ultimately, I mean to template the overloaded operator as template <class T> std::ostream& operator<<(std::ostream& os, const T* arr) or the like, and explicitly instantiate it for several types (int, char, float, double, etc.), so I have a uniform format.

---

I usually overload operator<< for vector<T> and other STL containers. That can easily be done since the objects know their size.

Is there a way to overload operator<< for an array of, say, doubles? On one hand, it seems one would need to pass the size somehow (it is unknown at compile time). On the other hand, there seems to be no mechanism for this (AFAIK... I leave it for the knowledgeable to answer).

I.e., I want

int n = 10;
double * pd1 = new double[n];
double pd2[n] = {};
...
cout << pd1 << endl;
cout << pd2 << endl;

I know I can define my custom print, but I want to know if I can work the <<-way.

Answer 1

The following example allows you to use:

{
   int v[5]{1,2,3,4,5};
   std::cout << arrayView(v);

   int *v2 = new int[5];
   std::cout << arrayView(v2, 5);
}

by defining

#include <iostream>

template<class Type>
class ArrayView
{
public:
    const Type *const begin, *const end;
};

// creates an ArrayView from a pointer and the number of items
template<class Type>
ArrayView<Type> arrayView(const Type* ptr, size_t items)
{
    return { ptr, ptr + items };
}

// creates an ArrayView from a fixed size array
template<class Type, size_t Size>
ArrayView<Type> arrayView(Type (&ptr)[Size])
{
    return { ptr, ptr + Size };
}

// outputs an ArrayView
template<class Type>
std::ostream& operator<<(std::ostream& s, ArrayView<Type> v)
{
    for (auto it = v.begin; it != v.end; ++it)
        s << *it;
    return s;
}

int main(int argc, char** argv)
{
    double v1[] = { 1, 2, 3, 4 };
    double* v2 = new double[5];

    for (int i = 0; i < 5; ++i)
        v2[i] = i + 10.0;

    std::cout << arrayView(v1) << std::endl;

    std::cout << arrayView(v2, 5) << std::endl;

    return 0;
}

The arrayView template function initializes an instance of the ArrayView template class which carries pointer and size (in the form of begin and end pointer).

For fixed size arrays this is not as efficient as it could be. A more efficient solution would be to create a dedicated template which stores the array size within its type:

template<class Type, size_t Size>
class FixedArrayView
{
public:
    const Type* const begin;
};

// creates an ArrayView from a fixed size array
template<class Type, size_t Size>
FixedArrayView<Type, Size> fixedArrayView(Type(&ptr)[Size])
{
    return { ptr };
}

// outputs a FixedArrayView
template<class Type, size_t Size>
std::ostream& operator<<(std::ostream& s, FixedArrayView<Type, Size> v)
{
    for(size_t i = 0; i < Size; ++i)
        s << v.begin[i];
    return s;
}

This could also be done without the need of an extra template class

template<class Type, size_t Size>
std::ostream& operator<<(std::ostream& s, Type(&arr)[Size])
{
    for (size_t i = 0; i < Size; ++i)
        s << arr[i];
    return s;
}

which allows you to write

{
   int v[5]{1,2,3,4,5};
   std::cout << v;
}

But the latest template operator<< has a big problem which strikes you if you , for example, try to output some string literal with std::cout << "abc";

However, there is a solution using SFINAE to make this template not handle "const char" (for which there already is an operator<< defined by <iostream>):

template<class Type, size_t Size, typename std::enable_if<!std::is_same<Type, const char>::value>::type* = nullptr>
std::ostream& operator<<(std::ostream& s, Type(&ptr)[Size])
{
    for (size_t i = 0; i < Size; ++i)
        s << ptr[i];
    return s;
}

Answer 2

To get plain old array to with with cout, you can provide an overload like

template <typename T, std::size_t N, std::enable_if_t<!std::is_same_v<char, std::decay_t<T>>, bool> = true> 
// SFINAE needed here for char arrays like cout << " "
std::ostream& operator <<(std::ostream& os, T(&array)[N])
{
    for (const auto& elem : array)
        os << elem << " ";
    return os;
}

which allows you to write code like

int main()
{
    int arr[10]{1,2,3,4,5,6,7,8,9,10};
    std::cout << arr;
}

For an array that you allocate at run time, it gets a little trickier. Pointers in C++ know nothing about the size of the object they point to, or at least as far as the standard is concerned. That means there isn't a portable way to get the size of the array the pointer points to. To get around that, we can leverage std::span from C++20. If you don't have that you can write your own or get an open source version. Doing that gives you an overload like

template <typename T, std::size_t Extent> 
std::ostream& operator <<(std::ostream& os, std::span<T, Extent> array)
{
    for (const auto& elem : array)
        os << elem << " ";
    return os;
}

And then you would use it like

int main()
{
    int * p_arr = new int[10]{21,22,23,24,25,26,27,28,29,20};
    std::cout << std::span{p_arr, 10};
}

It's not exactly the syntax you are looking for, but it only requires you to write the one overload (and potentially span).