C++ more than one instance of overloaded function matches the argument list when creating a header file

Question

Within my main file of my program I have the following declarations

int main()
{
    Customer c;
    Part p;
    Builder b;
    auto partsVec =  readpartFile();
    auto customerVec = readcustomerFile();
    auto builderVec = readbuilderFile();

    fexists("Parts.txt");
    complexity(c, partsVec);
    robotComplexity(partsVec,customerVec);
    writeFile(buildAttempt(b, complexity(c, partsVec), variability(customerVec, builderVec)));
}

My header file consists of the following

vector<Part> readpartFile();

vector<Customer> readcustomerFile();

vector<Builder> readbuilderFile();

float complexity(const Customer& c, const std::vector<Part>& parts);

void robotComplexity(vector<Part> vecB, vector<Customer> vecC);

double variability(const vector<Customer>& customerList, const vector<Builder>& builderList);

vector<double> buildAttempt(Builder b, double variaiblity, double complexityRobot);

void writeFile(vector<double> build);

All functions link up except for robotComplexity. My declaration of this function in main creates the following error.

more than one instance of overloaded function "robotComplexity" matches the argument list: -- function "robotComplexity(const std::vector> &parts, const std::vector> &customers)" -- function "robotComplexity(std::vector> vecB, std::vector> vecC)" -- argument types are: (std::vector>, std::vector>)

im not sure why im getting this error or how to resolve it

score 5 · Accepted Answer · answered Apr 19 '20 at 05:28

5

You have a mismatch between declaration in header and definition (which also serves as declaration):

void robotComplexity(vector<Part> vecB, vector<Customer> vecC);
void robotComplexity(const vector<Part>& vecB, const vector<Customer>& vecC);

Whereas parameter names can mismatch, types shouldn't, else, you create another overload.

answered Apr 19 '20 at 05:28

Jarod42

203,559
14
181
302

ah okay that fixed it. How come making it a const made a different – David Ling Apr 19 '20 at 05:31
`const std::vector&` and `std::vector` are different parameter type, the former is passed by const reference, the later is passed by value, so create a copy. – Jarod42 Apr 19 '20 at 05:51
would it be possible if i talked to you through message? – David Ling Apr 19 '20 at 06:05
Which is your questions? – Jarod42 Apr 19 '20 at 06:07
When i run the code i get of errors. I can place them in a file for if you wish but there are a few that im unsure of – David Ling Apr 19 '20 at 06:11
https://pastebin.com/4VCevJN8 here are all my errors. Alot of them are the same but for different aspects – David Ling Apr 19 '20 at 06:11
You might probably ask another question. provide MCVE. – Jarod42 Apr 19 '20 at 06:13
#include/forward declaration are missing. – Jarod42 Apr 19 '20 at 06:14
my new errors https://pastebin.com/nJHKEExQ. I would but theres that many different types i dobut anyone would properly answer without each quesiton being in the title. Its an issue that ive had with stack from the start. – David Ling Apr 19 '20 at 06:15
which includes are missing? – David Ling Apr 19 '20 at 06:16
Let us [continue this discussion in chat](https://chat.stackoverflow.com/rooms/211995/discussion-between-jarod42-and-david-ling). – Jarod42 Apr 19 '20 at 06:18
Go line by line. Start with #include . Then move on to forward declarations or extern if needed, especially if something is only defined in a .cpp – Paul Renton Apr 19 '20 at 06:18

Paul Renton · Answer 2 · 2020-04-19T05:55:12.430

Jarod42's Answer is quite correct, but I want to add to it and provide a helpful methodology for future C++ coding.

When function signatures differ, the compiler will not complain. At best, you will receive a cryptic or hard to read linker error. This is especially common with inheritance and virtual functions. Even worse, sometimes they will work but actually call a new function with a different signature on a child class that doesn't match the base class.

There is a keyword in C++11 (and newer versions) called override. Here is a more in depth discussion about what they keyword does: OverrideKeywordLink

When this keyword is used on a virtual function, it becomes a compile error when the intended virtual function override does not match the base class function signature. Also, it gives a very human readable reason why the function override did not occur.

You mentioned in a comment that 'How come const made it different"? The answer is it all comes down to function signatures. Consider these two functions within a class.

class MyClass {
    int CalculateSomething();
    int CalculateSomething() const;
}

The const actually changes the function signature. They are considered two different functions. The bottom line is, always try to make errors compile errors over run-time errors. Use keywords that protect you from some few tribal C++ knowledge traps that exist.

C++ more than one instance of overloaded function matches the argument list when creating a header file

2 Answers2