«

Hi,

Will two symbols with the same name but in different .cpp files clash?
E.g.

file1.cpp

int varA;


file2.cpp

int varA;


Will varA clash during linking? Of course I can test it myself, but is
there a possibility that they are allowed to clash but the compiler
chooses one of them?

Sometimes I've seen compiler messages like: "multiple definitions of X,
ignoring the latter".


Thanks,
Daniel

DeMarcus wrote:
> Hi,
>
> Will two symbols with the same name but in different .cpp files clash?
> E.g.
>
> file1.cpp
>
> int varA;
>
>
> file2.cpp
>
> int varA;
>
>
> Will varA clash during linking? Of course I can test it myself, but is
> there a possibility that they are allowed to clash but the compiler
> chooses one of them?
>
> Sometimes I've seen compiler messages like: "multiple definitions of X,
> ignoring the latter".
>
>
> Thanks,
> Daniel

Wait, I just came to think of that I have to declare them static!
I.e.

file1.cpp

static int varA;

file2.cpp

static int varA;


It was a long time since I used that.

* DeMarcus:
> Hi,
>
> Will two symbols with the same name but in different .cpp files clash?

Depends what you mean by "clash".

If the symbols have extern linkage then C++ generally does not support that.
It's called the "ODR", "One Definition Rule". But a linker may not necessarily
detect the clash -- e.g. 'int a[5]' one place and 'int* a' another place.

There are some execptions, where you are allowed multiple definitions of extern
linkage things.

The most important is "inline" routines.

A similar exception is there for static lifetime data in templates.


> E.g.
>
> file1.cpp
>
> int varA;
>
>
> file2.cpp
>
> int varA;
>
>
> Will varA clash during linking?

Depends on the linker.

But the code above is not well-defined C++.


> Of course I can test it myself, but is
> there a possibility that they are allowed to clash but the compiler
> chooses one of them?

No, not with the example above.

You can do that via the exception for templates mentioned above.

E.g., in each compilation unit, ...

template< class Dummy >
struct Var_ { static int a; };

template< class Dummy >
int Var_<Dummy>::a = 0;

typedef Var_<void> Var;

.... then use 'Var::a'.


> Sometimes I've seen compiler messages like: "multiple definitions of X,
> ignoring the latter".

That sounds like you're in violation of C++ rules.


Cheers & hth.,

- Alf

>>
>> file1.cpp
>>
>> int varA;
>>
>>
>> file2.cpp
>>
>> int varA;
>>
>>
>> Will varA clash during linking?
>
> Depends on the linker.
>
> But the code above is not well-defined C++.
>
>

If I define the variables like this

file1.cpp
static int varA;

file2.cpp
static int varA;

Am I allowed to send either varA pointer to other places in the application?

DeMarcus <> writes:

> DeMarcus wrote:
>> Hi,
>>
>> Will two symbols with the same name but in different .cpp files clash?
>> E.g.
>>
>> file1.cpp
>>
>> int varA;
>>
>>
>> file2.cpp
>>
>> int varA;
>>
>>
>> Will varA clash during linking? Of course I can test it myself, but
>> is there a possibility that they are allowed to clash but the
>> compiler chooses one of them?
>>
>> Sometimes I've seen compiler messages like: "multiple definitions of
>> X, ignoring the latter".
>>
>>
>> Thanks,
>> Daniel
>
> Wait, I just came to think of that I have to declare them static!
> I.e.
>
> file1.cpp
>
> static int varA;
>
> file2.cpp
>
> static int varA;
>
>
> It was a long time since I used that.

This particular use of the static keyword is deprecated in C++, IIRC.
To ensure that your two variables are not visible outside the
translation unit they are required in, use un-named namespaces:

// file1.cpp

namespace {
int varA;
}


// file2.cpp
namespace {
int varA;
}

Regards

Paul Bibbings

DeMarcus <> writes:

>
> If I define the variables like this
>
> file1.cpp
> static int varA;
>
> file2.cpp
> static int varA;
>
> Am I allowed to send either varA pointer to other places in the
> application?

Are you able to say a little more about what you are trying to achieve?
With the little information we have, it strikes me, at least, as a
little convoluted. Your question began with name clashing, then sought
a method to make your same-named variables TU-local, and now you are
asking how you can refer to these same-named variables outside of the TU
they're defined in.

Questions to be asked include, in the first instance, "Why are your
variables named the same?" "What application-wide visibility do you want
for these variables?" Then you might want to ask yourself to what
extent your answers to these questions conflict.

Regards

Paul Bibbings

* DeMarcus:
>>>
>>> file1.cpp
>>>
>>> int varA;
>>>
>>>
>>> file2.cpp
>>>
>>> int varA;
>>>
>>>
>>> Will varA clash during linking?
>>
>> Depends on the linker.
>>
>> But the code above is not well-defined C++.
>>
>>
>
> If I define the variables like this
>
> file1.cpp
> static int varA;
>
> file2.cpp
> static int varA;
>
> Am I allowed to send either varA pointer to other places in the
> application?

Yes, but keep in mind that here they're two distinct variables.


Cheers & hth.,

- Alf

Paul Bibbings wrote:
> DeMarcus <> writes:
>
>> If I define the variables like this
>>
>> file1.cpp
>> static int varA;
>>
>> file2.cpp
>> static int varA;
>>
>> Am I allowed to send either varA pointer to other places in the
>> application?
>
> Are you able to say a little more about what you are trying to achieve?
> With the little information we have, it strikes me, at least, as a
> little convoluted. Your question began with name clashing, then sought
> a method to make your same-named variables TU-local, and now you are
> asking how you can refer to these same-named variables outside of the TU
> they're defined in.
>
> Questions to be asked include, in the first instance, "Why are your
> variables named the same?" "What application-wide visibility do you want
> for these variables?" Then you might want to ask yourself to what
> extent your answers to these questions conflict.
>

I want to achieve the following.

file_class.cpp
const MessageClass ERROR( "Could not find file" );

class FileClass
{
public:
FileClass()
{
GlobalRegister::register( &ERROR );
}

void open( string s )
{
if( /* Error when opening file */ )
std::cerr << ERROR << std::endl;
}
};

calculation_class.cpp
const MessageClass ERROR( "Could not calculate" );

class CalculationClass
{
public:
CalculationClass()
{
GlobalRegister::register( &ERROR );
}

void calculate()
{
if( /* Error during calculation */ )
std::cerr << ERROR << std::endl;
}
};


I want to allow any file be able to use the symbol ERROR but at the same
time they shall be able to register the pointer to that variable without
clashing with other variables with the same symbol name.

Paul Bibbings wrote:
> DeMarcus <> writes:
>
>> DeMarcus wrote:
>>> Hi,
>>>
>>> Will two symbols with the same name but in different .cpp files clash?
>>> E.g.
>>>
>>> file1.cpp
>>>
>>> int varA;
>>>
>>>
>>> file2.cpp
>>>
>>> int varA;
>>>
>>>
>>> Will varA clash during linking? Of course I can test it myself, but
>>> is there a possibility that they are allowed to clash but the
>>> compiler chooses one of them?
>>>
>>> Sometimes I've seen compiler messages like: "multiple definitions of
>>> X, ignoring the latter".
>>>
>>>
>>> Thanks,
>>> Daniel
>> Wait, I just came to think of that I have to declare them static!
>> I.e.
>>
>> file1.cpp
>>
>> static int varA;
>>
>> file2.cpp
>>
>> static int varA;
>>
>>
>> It was a long time since I used that.
>
> This particular use of the static keyword is deprecated in C++, IIRC.
> To ensure that your two variables are not visible outside the
> translation unit they are required in, use un-named namespaces:
>
> // file1.cpp
>
> namespace {
> int varA;
> }
>
>
> // file2.cpp
> namespace {
> int varA;
> }
>
> Regards
>
> Paul Bibbings

Thanks!!!

Victor Bazarov wrote:
> DeMarcus wrote:
>> Paul Bibbings wrote:
>>> DeMarcus <> writes:
>>>
>>>> If I define the variables like this
>>>>
>>>> file1.cpp
>>>> static int varA;
>>>>
>>>> file2.cpp
>>>> static int varA;
>>>>
>>>> Am I allowed to send either varA pointer to other places in the
>>>> application?
>>>
>>> Are you able to say a little more about what you are trying to achieve?
>>> With the little information we have, it strikes me, at least, as a
>>> little convoluted. Your question began with name clashing, then sought
>>> a method to make your same-named variables TU-local, and now you are
>>> asking how you can refer to these same-named variables outside of the TU
>>> they're defined in.
>>>
>>> Questions to be asked include, in the first instance, "Why are your
>>> variables named the same?" "What application-wide visibility do you want
>>> for these variables?" Then you might want to ask yourself to what
>>> extent your answers to these questions conflict.
>>>
>>
>> I want to achieve the following.
>>
>> file_class.cpp
>> const MessageClass ERROR( "Could not find file" );
>>
>> class FileClass
>> {
>> public:
>> FileClass()
>> {
>> GlobalRegister::register( &ERROR );
>
> What does that do?
>

It registers the ERROR MessageClass to a global register that keeps
track of all messages to give them correct language.

Actually the MessageClass looks more like this.

const MessageClass ERROR( "Could_not_find_file_id" );

where ERROR when used picks up correct language string.

>> }
>>
>> void open( string s )
>> {
>> if( /* Error when opening file */ )
>> std::cerr << ERROR << std::endl;
>> }
>> };
>>
>> calculation_class.cpp
>> const MessageClass ERROR( "Could not calculate" );
>>
>> class CalculationClass
>> {
>> public:
>> CalculationClass()
>> {
>> GlobalRegister::register( &ERROR );
>
> What does that do?
>
>> }
>>
>> void calculate()
>> {
>> if( /* Error during calculation */ )
>> std::cerr << ERROR << std::endl;
>> }
>> };
>>
>>
>> I want to allow any file be able to use the symbol ERROR but at the
>> same time they shall be able to register the pointer to that variable
>
> Why? What for?
>
> > without
>> clashing with other variables with the same symbol name.
>
> What does registering have to do with compilation? Are you confusing
> run-time behavior (of your system) with the behavior of the compiler
> (who determines and reports "name clashes")?
>

I want to be able to use the same symbols (here symbol ERROR) in
different places. The symbols then may clash in link-time (unless I put
them in different namespaces as suggested), however, each and every
MessageClass are registered in a global register where the language can
be changed.