The same function in two different CPP files. How do I accomplish this?

Question

For my homework, this is my assignment:

Create 5 files. Driver.cpp, f.h, f.cpp, g.h, g.cpp. f and g should implement a function called hello. Driver should call hello from f and g.

Example Output:

hello from f

hello from g

Press any key to continue . . .

I have all these files created, but what I dont understand is how can the same function hello() exist in two files and be called from the driver.cpp file? any help would be greatly appreciated!

edit: The error I get is "fatal error LNK1169: one or more multiply defined symbols found". This is referring to the two hello() functions. How do I fix this?

We have touched upon them a bit but I'm not very familiar with them. — user2056120
– user2056120, Commented Oct 26, 2013 at 18:44
C++ has overloading: you can have 2 different functions hello(int) and hello(char). This seems silly, but maybe enough for an assignment. — anatolyg
– anatolyg, Commented Oct 26, 2013 at 18:47
@anatolyg this is bad practice. Namespaces should be used here. — Waqar
– Waqar, Commented Oct 26, 2013 at 18:56

Dietmar Kühl · Accepted Answer · 2013-10-26 19:00:12Z

Globally visible entities are allowed to have only one definition. Thus, you can't have the same function hello() defined in multiple translation units. There are a few separate approaches how to define equally named functions multiple times:

Overloaded function can have the same name as long as they differ in their arguments in some way. For example, you could have each of the hello() functions take an argument which differs between the different versions (note: I'm not suggesting this approch). For example:
```
void hello(bool) { std::cout << "hello(bool)\n"; }
void hello(int)  { std::cout << "hello(int)\n"; }
```
You can define the names in different namespaces. This makes the fully qualified name actually different, i.e., the conflict is prevented by just using a different scope, e.g.:
```
namespace a { void hello() { std::cout << "a::hello()\n"; }
namespace b { void hello() { std::cout << "b::hello()\n"; }
```
Assuming you call your function from a function in the local file, you can move the function from being globally visible to being only locally visible using the static keyword. Functions with local visibility do not conflict between different translation units. For example:
```
// file a.cpp
static void hello() { std::cout << "a.cpp:hello()\n"; }
void a() { hello(); }

// file b.cpp
static void hello() { std::cout << "b.cpp:hello()\n"; }
void b() { hello(); }
```

Which of these versions your teach is actually after, I don't know. Each one has their use, though, and it is useful to know the different variations.

In case someone claims that for completeness I should have included virtual functions: note that overriding a function is actually also creating an overload (the virtual function in the base and the overriding function differ in the implicity passed object), i.e., the use of virtual functions is already covered.

Waqar · Accepted Answer · 2013-10-26 19:06:33Z

2

You should use namespaces :

In f.h

:

namespace mynamespace {
  void hello(); 
}

In f.cpp

void mynamespace::hello()
{
    /... function definition here
}

In main()

int main()
{
   mynamespace :: hello();   // calls hello defined in f.cpp
}

For a good introduction to namespaces. Namespaces

answered Oct 26, 2013 at 19:06

Waqar

9,5496 gold badges39 silver badges47 bronze badges

Collectives™ on Stack Overflow

The same function in two different CPP files. How do I accomplish this?

2 Answers 2

Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related