如何从std :: array中推导出数组大小 <T, N> ::指针成员/依赖类型？

Question

My goal here is to write safe replacement for strcpy for case when destination buffer size is known during compilation, and I would like for buffer size to be deduced, so user won't need to know it. For example:

char xs[2] = { 0 };
strcpy(xs, "abc"); // buffer overflow!
printf("[%s]\n", xs);

Output for this will (hopefully) be:

[abc]

For simple case, when C-style array is passed, it can be written without much fuss:

template<size_t N>
char * safe_strcpy(char (& dst)[N], const char * src) noexcept {
    std::snprintf(dst, N, "%s", src);
    return & dst[0];
}

Size of array is deduced, snprintf takes care of placing terminating null byte, voilà.

I can sort-of adapt it to std::array as well:

template<size_t N>
typename std::array<char, N>::pointer
safe_strcpy(std::array<char, N> & dst, const char * src) noexcept {
    std::snprintf(dst.data(), N, "%s", src);
    return dst.data();
}

But this version is not really a drop-in replacement:

std::array<char, 2> ys = {};
strcpy(ys.data(), "abc"); // overflow!
safe_strcpy(ys, "abc");   // ok, but I needed to remove .data()

I want following case to work ok:

safe_strcpy(ys.data(), "abc"); // "a" should appear in buffer

dependent type of ys.data() is std::array<char, 2u>::pointer {aka char*} , so I think it should be possible to deduce array size out of this, but I can't figure out how :/

When I try something like this:

template<size_t N>
typename std::array<char, N>::pointer
safe_strcpy(typename std::array<char, N>::pointer & dst, const char * src) {
    // etc...
}

compilation fails with error:

error: no matching function for call to ‘safe_strcpy(std::array<char, 2u>::pointer, const char [4])’
safe_strcpy(ys.data(), "abc");
                            ^
(...)
note:   template argument deduction/substitution failed:
note:   couldn't deduce template parameter ‘N’

I tried with gcc 5.1.1 and clang 3.5.0, error in both is essentially the same. Is it possible to deduce type out of dependent type in C++ at all?

[edit] to all you kind people saying, that I should use std::string - you're missing the point here. I could've written same question with any STL container and ::iterator instead of ::pointer .

Answer 1

The data() member of the template<class T> array in namespace std is -according to the C++11 standard- declared as follows

T * data() noexcept;
const T * data() const noexcept;

but not like this:

pointer data() noexcept;
const_pointer data() const noexcept;

Even if it had been declared using the typedef there is no difference. Consider your example code:

std::array<char, 2> ys = {}; // 1
strcpy(ys.data(), "abc"); // 2
safe_strcpy(ys, "abc"); // 3

// 1

Compiler instantiates std::array<char, 2> . Which makes the typedef pointer = char* and compiles (if ever used) a imaginary member pointer data() with the following signature:

char* data();

The typedef is substituted because typedefs and alias names are syntactic sugar for the programmer - not the compiler. The compiler knows that this is char* so there it is.

// 2

You call the template using (as your first argument) a function that has the signature char*(void) . (And again std::array<char,2>::pointer is not a type of its own but char* ). Therefore, the call is void(char*, char const*) and this is what the compiler is trying to deduce the template from. And this call does not exhibit any information about the array size, nor does it even know about the fact that the pointer comes from an array in the first place.

// 3

Here your call is

void(std::array<char, 2> &, char const *);

and the compiler can deduce size and even character types if required.

Answer 2

The problem you're encountering is that std::array<char, N>::pointer is char* for all N , so when you call ys.data() you pass a char* to the function and there are infinite N that all match. This the compiler fails it as ambiguous. I took a look at array and I can't see any way to create a drop-in replacement that you're looking for.

But since you're writing C++ you can solve the problem just by using std::string instead of trying to deal with C-strings.

Answer 3

As others said there is no pointer member in std::array that has the information about the size, specially pointer doesn't have that information.

A very non portable alternative is to use ._M_elems instead of .pointer in GNU C++.

int main(){
  std::array<double, 10> arr;
  assert( std::extent<decltype(arr._M_elems)>() == arr.size() );
}

Should std::array have a standard carray and carray_type member? perhaps yes. Although this variable will decay so easily in a pointer that it won't be very useful.