Class: Multidimensional array initializer

So I have made my first class.
It calculates the area of a triangle from the position of the vertices.

I was wondering if it is possible to have only one variable, and not three (ver1, ver2, ver3), in the constructor?

Code:

---

#include <iostream>

using namespace std;

class Triangle{
public:
    float ver1[1][2];
    float ver2[1][2];
    float ver3[1][2];

private:
    float area_formula(){
        float x1 = ver1[0][0];
        float y1 = ver1[0][1];
        float x2 = ver2[0][0];
        float y2 = ver2[0][1];
        float x3 = ver3[0][0];
        float y3 = ver3[0][1];
        return .5*(x2*y3-x3*y2-x1*y3+x3*y1+x1*y2-x2*y1);
    }

public:
    float area(){
    return area_formula();
    }
};

int main(){
    //float ver0[3][2] = { {0,0}, {1,0}, {1,1}};
    //Triangle t1 = ver0;   
    Triangle t1 = {{0,0}, {1,0}, {1,1}};
    cout << t1.area() <<endl;
}

---

Well an array with dimension 1 is pretty pointless.

Also, when you start adding 1,2,3 suffixes to your variable names, it's screaming to be an array.

So don't you really have this?
float verts[3][2];

I would also recommend just writing a vertex class.

Code:

---

template <
  typename T, // only enable our class for 'float' or 'double' types
  typename = typename std::enable_if<std::is_floating_point<T>::value>::type>
struct vertex
{
  T x;
  T y;
};

---

And then do as Salem said,

Code:

---

template <typename T>
class triangle
{
private:
  std::array<vertex<T>, 3> vertices;
};

---

You can definitely drop the templated parts and just manually hard-code `float` or `double` but just as an fyi, you can actually control template types with enable_if. It's a pretty neat feature!

Code:

---

template
<
    typename T, // only enable our class for 'float' or 'double' types
    typename = std::enable_if_t<std::is_floating_point_v<T>> // C++14
>
struct vertex
{
  T x;
  T y;
};

---

(Didn't try to compile, though.)

The _v types aren't implemented in any stable compiler releases yet afaik.

Yeah, I normally just manually polyfill a lot of that functionality and will just type:

Code:

---

template <bool B, typename T = void>
using enable_if_t = typename std::enable_if<B, T>::type;

template <typename T>
constexpr bool is_floating_point_v = std::is_floating_point<T>::value;

---

Note, these are ripped pretty much straight from cppreference.com

I'm continually amused by those who pollute and complicate their implementation by supporting double and float, when float is such a garbage type.

Quote:

---

Originally Posted by whiteflags

I'm continually amused by those who pollute and complicate their implementation by supporting double and float, when float is such a garbage type.

---

Well, I think `is_floating_point` also supports the `long double` type as well.

`float` and `double` support make more sense in a CUDA context where size difference and hardware differences can have huge impacts on runtime performance. But supporting `float` still has uses in a CPU-based context as well. A `double` is twice as big as a `float` is and this can matter, for example, if you're allocating arrays.

Maybe I should have said, pick one or the other based on your specific usage restrictions, then.

Wow, that was many replies!
I must have forgotten to ask for getting e-mail when there are replies in this thread, since I haven't gotten any mail and there's been a lot of activity!
Shall start looking through your answers!

Yeah, we're just trying to go all Enterprise FizzBuzz on your simple code snippet XD

@whiteflags

I never actually asked why you think float is a garbage type. So, why do you think it's a garbage type? I mean, it's not float's fault that it's inaccurate. Blame binary representations of decimals and users trying to always freaking divide 1 by 10.

I think float is a garbage type because it is the short int (or maybe even the char) of the floating point world.