Load an OpenGL buffer from file

You say that "the files are binary and contain raw data compatible with OpenGL." On what platform? Does your code need to work properly on both big endian and little endian platforms? If so, then any float values (likely all vertices' coordinates) are not compatible until you've arranged their bytes correctly. But that may be beyond the scope of your project. I thought I'd mention it just in case.

One suggestion to clean things up just a little: Why not make all the validation at the beginning into a separate function? Something like validateArguments() or something similar?

void validateArguments(const unsigned char vertexElementCount, 
    const GLenum vertexFormat, const GLenum bufferType)
{
    const std::unordered_set<GLenum> VALID_VERTEX_FORMATS = {GL_FLOAT, GL_UNSIGNED_INT, GL_UNSIGNED_BYTE};
    //bufferType and usageHint will be validated by OpenGL

    if(vertexElementCount < 1 || vertexElementCount > 4)
    {
        throw std::invalid_argument("Vertex element count must be in range <1,4>");
    }

    if(bufferType == GL_ELEMENT_ARRAY_BUFFER && vertexElementCount != 1)
    {
        throw std::invalid_argument("Buffer of type GL_ELEMENT_ARRAY_BUFFER must have element count of 1");
    }

    if(VALID_VERTEX_FORMATS.find(vertexFormat) == VALID_VERTEX_FORMATS.end())
    {
        throw std::invalid_argument("Invalid vertex format");
    }
}

Next, I'd put the memory allocation and file reading into a function by itself:

char* allocateAndReadBufferData (std::string const& bufferPath, const unsigned char vertexElementCount, GLuint *vertexCount=NULL)
{
    std::ifstream file;
    file.open(bufferPath, std::ios::binary | std::ios::in);

    if(!file.is_open())
    {
        throw std::runtime_error(std::string("Buffer file ") + bufferPath + " could not be opened");
    }

    file.seekg(0, file.end);
    const unsigned int length = file.tellg();
    file.seekg(0, file.beg);

    if(vertexCount != NULL)
    {
        std::size_t vertexSize;

        switch(vertexFormat)
        {
            case GL_FLOAT:
                vertexSize = sizeof(GLfloat);
                break;
            case GL_UNSIGNED_INT:
                vertexSize = sizeof(GLuint);
                break;
            case GL_UNSIGNED_BYTE:
                vertexSize = sizeof(GLubyte);
                break;
        }

        vertexSize *= vertexElementCount;
        *vertexCount = length/vertexSize;
    }

    char* buffer = new char [length];
    file.read(buffer, length);
    file.close();
    return buffer;
} 

And finally, the OpenGL stuff where you actually allocate and upload the data could be a separate function as well:

GLuint uploadBuffer(char*& buffer, const GLenum bufferType, 
    const int length, const GLenum usageHint)
{
    GLuint bufferID;
    glGenBuffers(1, &bufferID);

    glBindBuffer(bufferType, bufferID);
    glBufferData(bufferType, length, buffer, usageHint);

    return bufferID;
}

And then your function looks like this:

GLuint loadBufferFromFile(std::string const& bufferPath, 
    const unsigned char vertexElementCount, const GLenum vertexFormat, 
    const GLenum bufferType, GLuint *vertexCount, const GLenum usageHint)
{
    validateArguments(vertexElementCount, vertexFormat, bufferType);

    char* buffer = allocateAndReadBufferData(bufferPath, vertexElementCount, vertexCount);

    GLuint bufferID = uploadBuffer(buffer, bufferType, length, usageHint);

    // Clean up
    delete [] buffer;

    return bufferID;
}

To answer your questions, I think I mostly agree with @Gerard above on all of them. Having said that, if you want to avoid the dynamic allocation, you could use a std::vector and call reserve() once you know the number of elements you'll need. Something like this:

std::vector<GLfloat> buffer; // NOTE: Assumes float data
allocateAndReadBufferData(bufferPath, vertexElementCount, buffer, vertexCount); // Note: buffer is now a parameter

and then in allocateAndReadBufferData() at the end, do this:

buffer.resize(*vertexCount); // Note you'll have to calculate vertex count even if variable is NULL in this case, but I think you get the idea
file.read(&buffer[0], length);