Overloading class name with integer variable

Question

I am learning C++ using the books listed here. In particular, i read about overloading. So after reading i am trying out different examples to clear my concept further. One such example whose output i am unable to understand is given below:

int Name = 0;

class Name 
{
    int x[2];  
};
void func()
{
    std::cout << sizeof(Name) << std::endl; //My question is: Why here Name refers to the integer variable Name and not class named Name
}

int main()
{
    func();
    
}

When i call func, then in the statement std::cout << sizeof(Name) << std::endl;, Name refers to the int Name and not class named Name. Why is this so? I expected that this would give me ambiguity error because there are two(different) entities with the same name. But the program works without any error and sizeof is applied to int Name instead of class named Name. I have read about function overloading in the books. But not about this kind of overloading. What is it called and what is happening here.

PS: I know that i can write std::cout<< sizeof(class Name); where sizeof will applied to the class named Name instead of variable int Name. Also, the example is for academic purposes. I know that use of global variable should be avoided. The question is not about how to solve this(say by not using same name for those two entities) but about what is happening.

This does not have anything to do with overloading. (The Standard: 'Each of two or more entities with the same name in the same scope, which must be functions or function templates, is commonly called an “overload”.') — molbdnilo, Feb 09 '22 at 12:31
In [basic.lookup.general] of the draft, there is a note that says "A type (but not a typedef-name or template) is therefore hidden by any other entity in its scope.", but the "therefore" seems to refer to the somewhat vague "In certain contexts, only certain kinds of declarations are included." At least it's not obvious to me what those "certain contexts" could be. — molbdnilo, Feb 09 '22 at 12:45
@molbdnilo I think "therefore" refers to the second sentence, not the first (otherwise the note would be placed differently). No matter whether the included declarations were restricted or not, if after consideration of any potential restrictions a non-type declaration is left, all type declarations are discarded, thereby hiding them, which also includes the usual unrestricted name lookup. — user17732522, Feb 09 '22 at 13:06
@user17732522 I would say that it refers to the whole item, and the second sentence's "[...] any such restriction [...]" in turn refers to "certain contexts" without so much as a hint as to the nature of those contexts. (It *is* a draft though, so a certain vagueness must be expected.) — molbdnilo, Feb 09 '22 at 13:22
Dup of [What happens when a class and a function have the same name?](https://stackoverflow.com/questions/26341979/what-happens-when-a-class-and-a-function-have-the-same-name) and/or https://stackoverflow.com/questions/34839886/struct-name-not-shadowing-variable-name — Language Lawyer, Feb 09 '22 at 14:58

463035818_is_not_an_ai · Answer 1 · 2022-02-09T12:42:42.853

What happens here is "shadowing". The global varible shadows the class of the same name.

What you can do to avoid it is:

(don't use global variables)
don't give the same name to different entities. Typically naming conventions are different for variables and types (eg name for the variable vs Name for the type).
make it explicit that you want to refer to the type via std::cout << sizeof(class Name) << std::endl;
if you really want them to have the same name you can place them in different namespaces.

For example:

#include <iostream>

namespace foo {
    int Name = 0;
}

namespace bar {
    class Name {
        int x[2];  
    };
}

namespace baz {
    void func() {
        std::cout << sizeof(foo::Name) << std::endl;
        std::cout << sizeof(bar::Name) << std::endl;
    }
}

int main()
{
    baz::func();
    
}

PS: As mentioned in a comment, this has nothing to do with overloading. Shadowing generally refers to entities having the same name while only one is accessible by that name. Overloading is very different from that, because when you overload a function then typically all the overloads are accessible and overload resolution decides which one to use.

score 1 · Accepted Answer · answered Feb 09 '22 at 14:30

Since you added the language-lawyer tag:

When a class and a variable of the same name are declared in the same scope, then the variable name hides the class name whenever name lookup would find both of them, see [basic.scope.hiding]/2 of the post-C++20 standard draft. (Note that there was significant rework of the wording for name lookup in the current standard draft for C++23, but it should have the same effect.)

I think this behavior, instead of making it an error to declare both a class and a variable of the same name in the same scope, was chosen for compatibility with C. In C the names of structs are in a separate namespace from variable names, so they are never ambiguous. For example with

int Name = 0;

struct Name 
{
    int x[2];  
};

in C, whenever you write just Name it refers to the variable. If you want to refer to the type you must use struct Name. C++ eliminates the requirement to use the struct prefix to refer to unambiguous structs, but with the rules as they are, name lookup for both Name and struct Name will have the same results in C and C++.

Overloading class name with integer variable

2 Answers2