About 200 Errors When Using cmath in Visual Studio 2015

Question

Trying to get code that was compilable in g++ to compile in VS2015. I looked around SO & Google with not much luck, yet cmath is documented in MSDN. I'm guessing I'm missing something really obvious or simple.

cmath is throwing a lot of errors most of the errors I'm getting during compilation, and half are in the form:

the global scope has no "<function>"

others are in the form

'<function>': redefinition; different exception specification

'<function>': identifier not found

'<function>': is not a member of "global namespace"

I don't understand why these errors are being thrown, but, if I use math.h, most of my compilation errors go away (including some in other standard libs that are crapping out, too).

Edit: As requested, the code. I'm using the sqrt & pow functions:

#include "vector.h"
#include <cmath>

using namespace vectormath;

vector::vector()
{
    this->_x = 0;
    this->_y = 0;
    this->_z = 0;
    this->_length = 0;
}
vector::vector(float x, float y, float z)
{
    this->_x = x;
    this->_y = y;
    this->_z = z;
    this->_length = sqrt(pow(_x, 2) + pow(_y, 2) + pow(_z, 2));
}

vector * vectormath::crossproduct(vector * a, vector * b)
{
    vector * result = new vector();

    result->_x = a->_y * b->_z - a->_z * b->_y;
    result->_y = a->_z * b->_x - a->_x * b->_z;
    result->_z = a->_x * b->_y - a->_y * b->_x;

    return result;
}

point::point()
{
    this->_x = 0.0;
    this->_y = 0.0;
    this->_z = 0.0;
}

point::point(float x, float y, float z)
{
    this->_x = x;
    this->_y = y;
    this->_z = z;
}

float vectormath::dotproduct(vector a, vector b)
{
    return a._x * b._x + a._y * b._y + a._z * b._z;
}

vector * vectormath::add(point * a, vector * b)
{
    vector * c = new vector();

    c->_x = a->_x + b->_x;
    c->_y = a->_y + b->_y;
    c->_z = a->_z + b->_z;

    return c;
}

Edit: and vector.h

namespace vectormath
{
    struct vector
    {
        float _x;
        float _y;
        float _z;
        float _length;

        vector();
        vector(float x, float y, float z);
    };

    struct point
    {
        float _x;
        float _y;
        float _z;

        point();
        point(float x, float y, float z);
    };
    vector * crossproduct(vector*, vector*);
    float dotproduct(vector a, vector b);
    vector * add(point * a, vector * b);
}

Answer 1

The difference between

#include <math.h>

and

#include <cmath>

is that the former puts things like sqrt and pow into the global namespace (i.e., you refer to them just by saying sqrt or pow) and the latter puts them into namespace std (i.e., you refer to them by saying std::sqrt or std::pow).

If you want not to have to prefix them with std:: all the time, you can put individual ones in the global namespace explicitly:

using std::sqrt;

or (though this is not recommended) you can pull in the whole of std like this:

using namespace std;

The trouble with that is that there are a lot of names in std and you probably don't really want them all.