Break OO privacy: Difference between revisions

Show how to access private or protected members of a class in an object-oriented language from outside an instance of the class, without calling non-private or non-protected members of the class as a proxy.

The intent is to show how a debugger, serializer, or other meta-programming tool might access information that is barred by normal access methods to the object but can nevertheless be accessed from within the language by some provided escape hatch or reflection mechanism.

as unidiomatic at best, and poor programming practice at worst.

Nonetheless, if your language intentionally maintains a double-standard for OO privacy, here's where you can show it off.

=={{header|ABAP}}==

 

Similar to C++, ABAP allows the declaration of friends which can be both classes and interfaces. All subclasses of friend classes are automatically friends of the source class. For example if classA (source) has classB as a friend and classC is a subclass of classB then classC is a friend of classA. Similarly all implementing classes of friend interfaces are friends of the source class. Also all interfaces which contain the befriended interface as a component are friends of the source class.

 

 

class my_class definition friends friendly_class .

 

endclass.

=={{header|Ada}}==

 

 

 

type Confidential_Stuff is tagged private;

Password: Password_Type := "default!"; -- the "secret"

end record;

 

 

 

procedure OO_Break_Privacy is

begin

Ada.Text_IO.Put_Line("The secret password is """ & Hack(C).Password & """");

 

The output shows that C holds, surprise, surprise, the default password:

<pre>The secret password is "default!"</pre>

 

using System.Reflection;

 

Console.WriteLine(answer);

}

{{out}}

=={{header|C++}}==

 

C++ has the 'friend' keyword to indicate that one class should have access to the private data of another. Here's a simple use case. (Please note that this code is not thread-safe.)

 

 

class CWidget; // Forward-declare that we have a class named CWidget.

delete pWidget3;

delete pWidget2;

{{out}}

Widget spawning. There are now 2 Widgets instanciated.

Widget dieing. There are now 1 Widgets instanciated.

Widget spawning. There are now 2 Widgets instanciated.

Widget dieing. There are now 1 Widgets instanciated.

 

Without the "friend" mechanism, it's still possible to meaningfully modify any member in another class, as long as you know that member's address in memory, and its type. Here's the same program as above, but using a pointer to m_uicount, rather a reference to the factory:

 

 

class CWidget; // Forward-declare that we have a class named CWidget.

delete pWidget3;

delete pWidget2;

=={{header|Clojure}}==

You can use the var-quote macro to get values from private variables. Here's an example of a variable 'priv' marked private in namespace 'a':

(ns a)

(def ^:private priv :secret)

user=> @#'a/priv ; succeeds

:secret

 

Clojure can also access Java private variables with the same strategy that Java uses. As a convenience, use the [http://clojuredocs.org/clojure_contrib/clojure.contrib.reflect/get-field get-field] function from clojure.contrib.reflect. Here's an example of grabbing the private field "serialVersionUID" from java.lang.Double:

user=> (get-field Double "serialVersionUID" (Double/valueOf 1.0))

-9172774392245257468

=={{header|Common Lisp}}==

 

A symbol can be present in more than one package, such that it can be internal in some of them, and external in others.

 

;; only these symbols are public

(:export :widget :get-wobbliness)

;; even read and evaluated. The symbol is internal and so cannot be used.

(format t "wobbliness: ~a~%" (slot-value *w* 'funky:wobbliness))

 

{{Out}} using CLISP:

*** - READ from #<INPUT BUFFERED FILE-STREAM CHARACTER #P"funky.lisp" @44>:

#<PACKAGE FUNKY> has no external symbol with name "WOBBLINESS"</pre>

 

=={{header|E}}==

 

 

{{improve|E|Show an example of such an evaluator once it is available.}}

 

=={{header|F_Sharp|F#}}==

{{trans|C#}}

open System.Reflection

 

let answer = fieldInfo.GetValue(myInstance)

printfn "%s = %A" (answer.GetType().ToString()) answer

{{out}}

<pre>System.Int32 = 42</pre>

=={{header|Factor}}==

From the [http://docs.factorcode.org/content/article-word-search-private.html documentation for private words]: ''"Privacy is not enforced by the system; private words can be called from other vocabularies, and from the listener. However, this should be avoided where possible."''

This example uses the private word ''sequence/tester'' from the vocabulary ''sets.private''. It tries to count the elements in an intersection of two sets.

 

( scratchpad ) { 1 2 3 } { 1 2 4 } sequence/tester count .

 

There is better way to do the same, without any private words.

 

( scratchpad ) { 1 2 3 } { 1 2 4 } intersect length .

=={{header|Forth}}==

{{works with|Forth}}

Needs the FMS-SI (single inheritance) library code located here:

http://soton.mpeforth.com/flag/fms/index.html

 

99 value x \ create a global variable named x

50 .. f1.x ! \ use the dot parser to access the private x without a message

f1 print \ 50

 

=={{header|Go}}==

Go has a <code>reflect</code> and <code>unsafe</code> package that together can do this.

A relevant Go Blog article is

[http://blog.golang.org/laws-of-reflection The Laws of Reflection].

 

import (

// package once we know what type it is (so we can use the

// correct pointer type, here *int):

fmt.Printf(" vp has type %-14T = %v\n", vp, vp)

fmt.Printf(" up has type %-14T = %#0x\n", up, up)

fmt.Printf(" p has type %-14T = %v pointing at %v\n", p, p, *p)

// or an incr all on one ulgy line:

*(*int)(unsafe.Pointer(v.Field(1).Addr().Pointer()))++

}

 

_, err := r.ReadByte()

fmt.Println("bufio.ReadByte returned error:", err)

{{out}}

<pre>

1: unexported int false

vp has type reflect.Value = <*int Value>

up has type unsafe.Pointer = 0xc208000208

p has type *int = 0xc208000208 pointing at 42

 

==Icon and {{header|Unicon}}==

Unicon implements object environments with records and supporting procedures for creation, initialization, and methods. The variables in the class environment can be accessed like any other record field. Additionally, with the ''fieldnames'' procedure you can obtain the names of the class variables.

 

 

Note: Unicon can be translated via a command line switch into icon which allows for classes to be shared with Icon code (assuming no other incompatibilities exist).

 

procedure main()

printf("foo var1=%i, var2=%i, var3=%i\n",var1,var2,var3)

end

 

{{libheader|Icon Programming Library}}

var 1 of foo x = 1

foo var1=-1, var2=2, var3=3</pre>

=={{header|J}}==

 

 

J does support a "[http://www.jsoftware.com/help/dictionary/dx003.htm Lock Script]" mechanism - to transform a J script so that it's unreadable. However, anyone with access to a machine running the code and ordinary developer tools or who understands the "locking" technique could unlock it.

=={{header|Java}}==

class Example {

}

 

 

 

 

 

}

{{out}}

<pre>

</pre>

=={{header|Logtalk}}==

Logtalk provides a ''context switching call'' control construct that allows a call to be executed as from within an object. It's mainly used for debugging and for writing unit tests. This control construct can be disabled on a global or per object basis to prevent it of being used to break encapsulation.

 

In the following example, a prototype is used for simplicity.

 

% be sure that context switching calls are allowed

bar(3).

 

After compiling and loading the above object, we can use the following query to access the private method:

X = 1 ;

X = 2 ;

X = 3

 

=={{header|Nim}}==

File oo.nim:

a: string

b: string

 

proc createFoo*(a, b, c): Foo =

By not adding a <code>*</code> to <code>Foo</code>'s members we don't export them. When we import this module we can't use them directly:

 

The easiest way to get a debug view of any data:

Output:

<pre>[a = 0x7f6bb87a7050"this a",

c = 12]</pre>

More fine-grained:

 

for key, val in fields(toAny(x)):

echo " is an integer with value: ", val.getBiggestInt

else:

Output:

<pre>Key a

Key c

is an integer with value: 12</pre>

=={{header|Objective-C}}==

In older versions of the compiler, you can simply access a private field from outside of the class. The compiler will give a warning, but you can ignore it and it will still compile. However, in current compiler versions it is now a hard compile error.

One solution is to use Key-Value Coding. It treats properties and instance variables as "keys" that you can get and set using key-value coding methods.

 

 

@interface Example : NSObject {

}

return 0;

{{out}}

<pre>

Another solution is to use a category to add methods to the class (you can have categories in your code modify any class, even classes compiled by someone else, including system classes). Since the new method is in the class, it can use the class's private instance variables with no problem.

 

 

@interface Example : NSObject {

}

return 0;

{{out}}

<pre>

Finally, you can access the instance variable directly using runtime functions.

 

#import <objc/runtime.h>

 

}

return 0;

{{out}}

<pre>

Hello, I am Edith

</pre>

 

=={{header|Oforth}}==

 

 

There is no other way to access attributes values from outside but to call methods on the object.

=={{header|Perl}}==

Perl's object model does not enforce privacy. An object is just a blessed reference, and a blessed reference can be dereferenced just like an ordinary reference.

sub new {

my $class = shift;

package main;

my $foo = Foo->new();

{{out}}

<pre>I am ostensibly private

I am ostensibly private</pre>

{{out}}

=={{header|PHP}}==

While normally accessing private variables causes fatal errors, it's possible to catch output of some debugging functions and use it. Known functions which can get private variables include: <code>var_dump()</code>, <code>print_r()</code>, <code>var_export()</code> and <code>serialize()</code>. The easiest to use is <code>var_export()</code> because it's both valid PHP code and doesn't recognize private and public variables.

 

{{works with|PHP|5.1}}

class SimpleClass {

private $answer = "hello\"world\nforever :)";

 

$new_class = eval($class_content);

 

Another way commonly used to access private and protected variables in PHP is to cast the object to an array. It's probably unintentional though looking on how casted array contains null bytes (probably "private" mark). This works unless a magic method for the cast operation is implemented:

{{works with|PHP|4.x}}

{{works with|PHP|5.x}}

class SimpleClass {

private $answer = 42;

$class = new SimpleClass;

$classvars = (array)$class;

 

{{works with|PHP|5.3}}

Since php 5.3, one can easily read and write any protected and private member in a object via reflection.

class fragile {

private $foo = 'bar';

$rp->setValue($fragile, 'haxxorz!');

var_dump($rp->getValue($fragile));

{{out}}

<pre>

}

</pre>

 

=={{header|Python}}==

Python isn't heavily into private class names. Although private class names can be defined by using a double underscore at the start of the name, such names are accessible as they are mangled into the original name preceded by the name of its class as shown in this example:

__private = 123

non_private = __private * 2

>>> mine._MyClassName__private

123

 

=={{header|Ruby}}==

Ruby lets you redefine great parts of the object model at runtime and provides several methods to do so conveniently. For a list of all available methods look up the documentation of <code>Object</code> and <code>Module</code> or call informative methods at runtime (<code>puts Object.methods</code>).

class Example

def initialize

p example.instance_variable_set :@private_data, 42 # => 42

p example.instance_variable_get :@private_data # => 42

=={{header|Scala}}==

override def toString = s"Hello, I am $name"

}

field.set(foo, "Edith")

println(foo)

=={{header|Sidef}}==

Sidef's object model does not enforce privacy, but it allows storing private attributes inside the container of an object, which is an hash:

has public = "foo"

method init {

 

# Access private attributes

 

=={{header|Tcl}}==

Tcl's object properties are just variables in the a per-instance namespace; all that's required to get hold of them is to discover the name of the namespace concerned:

 

oo::class create Example {

$e print

set [info object namespace $e]::name "Edith"

Hello, I am Eric

Hello, I am Edith

 

=={{header|zkl}}==

In zkl, privacy is more convention than enforced (unlike const or protected).

C.v; C.f; C.D; // all generate NotFoundError exceptions

However:

C.fcns[1]() //-->123

C.classes //-->L(Class(D))

In the case of private vars, the name isn't saved.

{{omit from|Standard ML|not OO}}