Why are private fields private to the type, not the instance?

by

I think one reason it works this way is because access modifiers work at compile time. As such, determining whether or not a given object is also the current object isn’t easy to do. For example, consider this code:

public class Foo
{
    private int bar;

    public void Baz(Foo other)
    {
        other.bar = 2;
    }

    public void Boo()
    {
        Baz(this);
    }
}

Can the compiler necessarily figure out that other is actually this? Not in all cases. One could argue that this just shouldn’t compile then, but that means we have a code path where a private instance member of the correct instance isn’t accessible, which I think is even worse.

Only requiring type-level rather than object-level visibility ensures that the problem is tractable, as well as making a situation that seems like it should work actually work.

EDIT: Danilel Hilgarth’s point that this reasoning is backwards does have merit. Language designers can create the language they want, and compiler writers must conform to it. That being said, language designers do have some incentive to make it easier for compiler writers to do their job. (Though in this case, it’s easy enough to argue that private members could then only be accessed via this (either implicitly or explicitly)).

However, I believe that makes the issue more confusing than it needs to be. Most users (myself included) would find it unneccessarily limiting if the above code didn’t work: after all, that’s my data I’m trying to access! Why should I have to go through this?

In short, I think I may have overstated the case for it being “difficult” for the compiler. What I really meant to get across is that above situation seems like one that the designers would like to have work.

More Related Contents:

  1. Why Doesn’t C# Allow Static Methods to Implement an Interface?
  2. How to capture value OOPS & Generic [closed]
  3. Implement a coin jar in C# [closed]
  4. What is the difference between a field and a property?
  5. Why not inherit from List?
  6. How to loop through all enum values in C#? [duplicate]
  7. Why is Multiple Inheritance not allowed in Java or C#?
  8. What is the difference between an interface and a class, and why I should use an interface when I can implement the methods directly in the class?
  9. How can I call the ‘base implementation’ of an overridden virtual method? [duplicate]
  10. Why can’t we change access modifier while overriding methods in C#?
  11. What does void mean in C, C++, and C#?
  12. Why is The Iteration Variable in a C# foreach statement read-only?
  13. Is there an alternative to bastard injection? (AKA poor man’s injection via default constructor)
  14. How abstraction and encapsulation differ?
  15. Why C# won’t allow field initializer with non-static fields?
  16. How do I target attributes for a record class?
  17. Why must we define both == and != in C#?
  18. Why aren’t variables declared in “try” in scope in “catch” or “finally”?
  19. Why can’t I declare C# methods virtual and static?
  20. Performance of “direct” virtual call vs. interface call in C#
  21. How to solve circular reference?
  22. The difference between virtual, override, new and sealed override
  23. C# code for association, aggregation, composition
  24. Is there a much better way to create deep and shallow clones in C#?
  25. C# : Converting Base Class to Child Class
  26. C# static member “inheritance” – why does this exist at all?
  27. Factory pattern in C#: How to ensure an object instance can only be created by a factory class?
  28. Getters and Setters are bad OO design? [duplicate]
  29. What is the difference between static methods in a Non static class and static methods in a static class?
  30. Why value-types are stored onto Stacks?

Leave a Comment