Re: typedef float float4[4]; std::vector<float4>; does not compile, why?

From:

Jeff Schwab <jeff@schwabcenter.com>

Newsgroups:

comp.lang.c++

Date:

Tue, 19 May 2009 14:17:25 -0400

Message-ID:

<O5ydnW1IHewoao_XnZ2dnUVZ_qWdnZ2d@giganews.com>

Brian Cole wrote:

On May 19, 11:18 am, Jeff Schwab <j...@schwabcenter.com> wrote:

Brian Cole wrote:

On May 19, 10:34 am, Jeff Schwab <j...@schwabcenter.com> wrote:

Brian Cole wrote:

On May 19, 2:01 am, SG <s.gesem...@gmail.com> wrote:

On 19 Mai, 00:12, Brian Cole <col...@gmail.com> wrote:

The following code will not compile in gcc 4.3.2 on Ubuntu 8.10
#include <vector>
typedef float float4[4];
int main()
{
std::vector<float4> vals;
}

As Alf said, float4 doesn't satisfy the vector templates' requirements
as a value type.
If your C++ implementation ships with the TR1 library extension or you
can install some TR1 implementation and/or Boost you could solve this
problem via:
typedef std::tr1::array<float,4> float4;

Apparently GCC considers this a bug (http://gcc.gnu.org/bugzilla/
show_bug.cgi?id=40192). So now I'm doubly confused.

It wasn't a bug. They should not have "fixed" it.

I'm not a language lawyer, is "float4" a pointer to an array of 4
floats? Or is it an array of 4 floats?

It's an array (in your original post). C++ raw arrays decay to
pointers, but that's not something you should need to worry about unless
you're manually laying out memory. You almost never should need a raw
array. Forget about raw arrays.

Basically if we define float4_t
as "struct float4_t { float x,y,z,w; };" is std::vector<float4>
equivalent to std::vector<float4_t> or std::vector<float4_t *>.

Neither. std::vector<float[4]> shouldn't even be legal.

FYI, the reason this arose is because I am toying with the OpenCL
libraries which defines the type:http://www.khronos.org/registry/cl/api/1.0/cl_platform.h
If it truly is illegal I think OpenCL should change the definition to
a struct to be friendlier with C++.

Khronos probably should have defined:

struct float4 { float values[4]; }

In C, though, it is common to use arrays directly as containers, for
historical reasons, and OpenCL is apparently based on C99. OpenCL is
full of other C-related nastiness, too; for example, it defines names
like float4 directly in the global namespace. Namespace pollution is a
real problem in large programs.

One easy way around the vector<float4> problem is to wrap float4 in your
own class.

There is a C++ wrapper layer being developed on top of OpenCL:
http://www.khronos.org/registry/cl/api/1.0/cl.hpp It will be part of
the 1.1 standard.

This is perhaps a nastiness that should be dealt with there now that I
am thoroughly convinced that cl_float4 does not play nice with C++.

That may be. It looks like they're at least thinking along the right
lines, using custom vector and size_t types to wrap arrays:

template <typename T, int N>
struct vector
{
     T value_[N];

     operator T* () { return value_; }
     operator const T* () const { return value_; }

     T& operator [](int index) { return value_[index]; }
     T operator [](int index) const { return value_[index]; }
};

} // namespace detail

/*!
  * \brief size_t class used to interface between C++ and
  * OpenCL C calls that require arrays of size_t values, who's
  * size is known statically.
  */
template <int N>
struct size_t : public detail::vector< ::size_t, N> { };