The first one is a read-only field, while the second one gets compiled as a pair of methods (and all reads of the property ProductLocation gets compiled into calls to the corresponding get method and writes to it gets compiled into calls to the set method; internally, these methods will read from / write to … Read more
Let’s not consider ethics for a moment. Let’s consider the standard. What you are proposing to do is nonstandard. See section 9.2, clause 12 of the standard. “The order of allocation of nonstatic members separated by an access-specifier is unspecified.” Therefore, if you have a class with private members, and a struct with no private … Read more
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; } … Read more
This should demonstrate how to solve it: import java.lang.reflect.Field; class Super { private int i = 5; } public class B extends Super { public static void main(String[] args) throws Exception { B b = new B(); Field f = b.getClass().getSuperclass().getDeclaredField(“i”); f.setAccessible(true); System.out.println(f.get(b)); } } (Or Class.getDeclaredFields for an array of all fields.) Output: 5
At the time you declare your member, you are still defining the A class, so the type A is still undefined. However, when you write A*, the compiler already knows that A stands for a class name, and so the type “pointer to A” is defined. That’s why you can embed a pointer to the … Read more
Because that’s how it works in C++. In C++ access control works on per-class basis, not on per-object basis. Access control in C++ is implemented as a static, compile-time feature. I think it is rather obvious that it is not really possible to implement any meaningful per-object access control at compile time. Only per-class control … Read more
If the class contains any template member functions you can specialize that member function to suit your needs. Even if the original developer didn’t think of it. safe.h class safe { int money; public: safe() : money(1000000) { } template <typename T> void backdoor() { // Do some stuff. } }; main.cpp: #include <safe.h> #include … Read more
No, there’s no way to do it. That would essentially be scoping in reverse. Methods defined inside the constructor have access to private variables because all functions have access to the scope in which they were defined. Methods defined on a prototype are not defined within the scope of the constructor, and will not have … Read more
The inner class is just a way to cleanly separate some functionality that really belongs to the original outer class. They are intended to be used when you have 2 requirements: Some piece of functionality in your outer class would be most clear if it was implemented in a separate class. Even though it’s in … Read more
The rules for auto are, for the most part, the same as for template type deduction. The example posted works for the same reason you can pass objects of private types to template functions: template <typename T> void fun(T t) {} int main() { Foo f; fun(f.Baz()); // ok } And why can we pass … Read more