C++ Multiple Static Functions With Same Name But Different Arguments [closed] - c++

Question

Closed. This question needs debugging details. It is not currently accepting answers.
Edit the question to include desired behavior, a specific problem or error, and the shortest code necessary to reproduce the problem. This will help others answer the question.
Closed 8 years ago.
Improve this question
It appears as though I stumbled across something odd while trying to write my own wrapper for the freeglut api. Basically, I am writing my own little library to make using freeglut easier. One of the first things that I am doing is attempting to implement my own Color class which will be fed into "glClearColor". I am also having it so that you can enter the colors in manually; this means that I will have multiple static methods with the same name but different parameters/arguments. I tried to compile this afterwards but received an error that makes me think that the compiler cant decide which method to use—which is odd considering the two methods in question are still different. One takes a Color3 class and the other a Color4.
Here is some source:
GL.H
#pragma once
#include "Vector3.h"
#include "Color3.h"
#include "Color4.h"
#include <string>
class GL
{
public:
static void initializeGL(int argc, char* argv);
static void initializeDisplayMode(unsigned int displayMode);
static void initializeWindowSize(int width, int height);
static void createWindow(std::string title);
static void mainLoop();
static void translate(const Vector3 &location);
static void translate(float x, float y, float z);
static void rotate(double rotation, float x, float y, float z);
static void rotate(double rotation, const Vector3& axis);
static void color3(const Color3 &color);
static void color4(const Color4 &color);
static void begin();
static void end();
static void pushMatrix();
static void popMatrix();
static void enable(int enableCap);
static void viewport();
static void polygonMode();
static void matrixMode();
static void clearColor(const Color3 &color);
static void clearColor(float red, float green, float blue);
static void clearColor(float red, float green, float blue, float alpha);
static void clearColor(const Color4 &color);
static void vertex3(const Vector3 &location);
static void vertex3(float x, float y, float z);
static void loadIdentity();
static void perspective();
static void depthFunction();
};
GL.cpp
#include "GL.h"
#include "freeglut.h"
void GL::clearColor(const Color3 &color)
{
glClearColor(color.getRed,color.getGreen,color.getBlue, 1.0f);
}
void GL::clearColor(float red, float green, float blue)
{
glClearColor(red, green, blue, 1.0f);
}
void GL::clearColor(float red, float green, float blue, float alpha)
{
}
void GL::clearColor(const Color4 &color)
{
}
And here is my compiler error:
1>------ Build started: Project: GameEngineToolkit, Configuration: Debug Win32 ------
1> Main.cpp
1>c:\the capsule\c++\get\gameenginetoolkit\gameenginetoolkit\main.cpp(47): error C2665: 'GL::clearColor' : none of the 4 overloads could convert all the argument types
1> c:\the capsule\c++\get\gameenginetoolkit\gameenginetoolkit\gl.h(610): could be 'void GL::clearColor(const Color4 &)'
1> c:\the capsule\c++\get\gameenginetoolkit\gameenginetoolkit\gl.h(607): or 'void GL::clearColor(const Color3 &)'
1> while trying to match the argument list '(Color3 *)'
1> GL.cpp
1>c:\the capsule\c++\get\gameenginetoolkit\gameenginetoolkit\gl.cpp(8): error C3867: 'Color3::getRed': function call missing argument list; use '&Color3::getRed' to create a pointer to member
1>c:\the capsule\c++\get\gameenginetoolkit\gameenginetoolkit\gl.cpp(8): error C3867: 'Color3::getGreen': function call missing argument list; use '&Color3::getGreen' to create a pointer to member
1>c:\the capsule\c++\get\gameenginetoolkit\gameenginetoolkit\gl.cpp(8): error C3867: 'Color3::getBlue': function call missing argument list; use '&Color3::getBlue' to create a pointer to member
1> Generating Code...
========== Build: 0 succeeded, 1 failed, 0 up-to-date, 0 skipped ==========
As you can see, it seems that the compiler cant decide between using the Color3 function or the color4 function; I don't understand why because it should be obvious which one to choose(the Color3 one is the one I am using in my main).
As per request, here is my Color3 class:
Color3.h
#pragma once
class Color3
{
public:
Color3();
Color3(float red, float green, float blue);
void setRed(float red);
void setGreen(float green);
void setBlue(float blue);
float getRed();
float getGreen();
float getBlue();
Color3 getColor();
~Color3();
private:
float red;
float green;
float blue;
};
Color3.cpp
#include "Color3.h"
Color3::Color3()
{
}
Color3::Color3(float red, float green, float blue)
{
setRed(red);
setGreen(green);
setBlue(blue);
}
Color3::~Color3()
{
}
float Color3::getRed()
{
return red;
}
float Color3::getGreen()
{
return green;
}
float Color3::getBlue()
{
return blue;
}
void Color3::setBlue(float blue)
{
this->blue = blue;
}
void Color3::setGreen(float green)
{
this->green = green;
}
void Color3::setRed(float red)
{
this->red = red;
}
Color3 Color3::getColor()
{
return *this;
}
The Solution:
Use pointers.
GL.cpp
#include "GL.h"
#include "freeglut.h"
void GL::clearColor(Color3* color)
{
glClearColor(color->getRed(),color->getGreen(),color->getBlue(), 1.0f);
}
void GL::clearColor(float red, float green, float blue)
{
glClearColor(red, green, blue, 1.0f);
}
void GL::clearColor(float red, float green, float blue, float alpha)
{
}
void GL::clearColor(Color4* color)
{
}
GL.H
#pragma once
#include "Vector3.h"
#include "Color3.h"
#include "Color4.h"
#include <string>
class GL
{
public:
static void initializeGL(int argc, char* argv);
static void initializeDisplayMode(unsigned int displayMode);
static void initializeWindowSize(int width, int height);
static void createWindow(std::string title);
static void mainLoop();
static void translate(const Vector3 &location);
static void translate(float x, float y, float z);
static void rotate(double rotation, float x, float y, float z);
static void rotate(double rotation, const Vector3& axis);
static void color3(const Color3 &color);
static void color4(const Color4 &color);
static void begin();
static void end();
static void pushMatrix();
static void popMatrix();
static void enable(int enableCap);
static void viewport();
static void polygonMode();
static void matrixMode();
static void clearColor(Color3* color); // Use pointers instead
static void clearColor(float red, float green, float blue);
static void clearColor(float red, float green, float blue, float alpha);
static void clearColor(Color4* color); // Same thing; no error. =P
static void vertex3(const Vector3 &location);
static void vertex3(float x, float y, float z);
static void loadIdentity();
static void perspective();
static void depthFunction();
};

Answer 1

Well first of all, you're passing a Color3 pointer into an overloaded function that takes two different references.
You have a range of options:
Don't pass a pointer (you have Color3 color in main(), don't pass &color, pass color)
De-reference the pointer to pass a reference (having a Color3* color in main(), pass *color not color)
Change the method or add one to accept a Color3 pointer. This is dumb and I don't advise it. But you can!
Also I know it's not a part of the question but it appears getRed, getGreen, and getBlue are methods that you should append () to.