Template:Short description In object-oriented programming, a member variable (sometimes called a member field) is a variable that is associated with a specific object, and accessible for all its methods (member functions).
In class-based programming languages, these are distinguished into two types: class variables (also called static member variables), where only one copy of the variable is shared with all instances of the class; and instance variables, where each instance of the class has its own independent copy of the variable.<ref>{{#invoke:citation/CS1|citation |CitationClass=web }}</ref>
ExamplesEdit
C++Edit
<syntaxhighlight lang="cpp">
class Foo {
int bar; // Member variable
public:
void setBar(const int newBar) {
bar = newBar;
}
};
int main () {
Foo rect; // Local variable
return 0;
}</syntaxhighlight>
JavaEdit
<syntaxhighlight lang="java"> public class Program {
public static void main(String[] args)
{
// This is a local variable. Its lifespan
// is determined by lexical scope.
Foo foo;
}
}
public class Foo {
/* This is a member variable - a new instance
of this variable will be created for each
new instance of Foo. The lifespan of this
variable is equal to the lifespan of "this"
instance of Foo
*/
int bar;
} </syntaxhighlight>
PythonEdit
<syntaxhighlight lang="python"> class Foo:
def __init__(self):
self._bar = 0
@property
def bar(self):
return self._bar
@bar.setter
def bar(self, new_bar):
self._bar = new_bar
f = Foo() f.bar = 100 print(f.bar) </syntaxhighlight>
Common LispEdit
<syntaxhighlight lang="lisp"> (defclass foo () (bar))
(defvar f (make-instance 'foo)) (setf (slot-value f 'bar) 100) (print (slot-value f 'bar)) </syntaxhighlight>
RubyEdit
<syntaxhighlight lang="ruby"> /*
Ruby has three member variable types: class, class instance, and instance.
- /
class Dog
# The class variable is defined within the class body with two at-signs # and describes data about all Dogs *and* their derived Dog breeds (if any) @@sniffs = true
end
mutt = Dog.new mutt.class.sniffs #=> true
class Poodle < Dog
# The "class instance variable" is defined within the class body with a single at-sign # and describes data about only the Poodle class. It makes no claim about its parent class # or any possible subclass derived from Poodle @sheds = false
# When a new Poodle instance is created, by default it is untrained. The 'trained' variable # is local to the initialize method and is used to set the instance variable @trained # An instance variable is defined within an instance method and is a member of the Poodle instance def initialize(trained = false) @trained = trained end
def has_manners? @trained end
end
p = Poodle.new p.class.sheds #=> false p.has_manners? #=> false </syntaxhighlight>
PHPEdit
<syntaxhighlight lang="php"> <?php
class Example {
/**
* Example instance member variable.
*
* Member variables may be public, protected or private.
*
* @var int
*/
public int $foo;
/**
* Example static member variable.
*
* @var bool
*/
protected static int $bar;
/**
* Example constructor method.
*
* @param int $foo
*/
public function __construct(int $foo)
{
// Sets foo.
$this->foo = $foo;
}
}
// Create a new Example object. // Set the "foo" member variable to 5. $example = new Example(5);
// Overwrite the "foo" member variable to 10. $example->foo = 10;
// Prints 10. echo $example->foo; </syntaxhighlight>
LuaEdit
<syntaxhighlight lang="lua"> --region example --- @class example_c --- @field foo number Example "member variable". local example_c = {} local example_mt = {__index = example_c}
--- Creates an object from example. --- @return example_c function example_c.new(foo)
-- The first table argument is our object's member variables.
-- In a Lua object is a metatable and its member variables are table key-value pairs.
return setmetatable({
foo = foo
}, example_mt)
end --endregion
-- Create an example object. -- Set the "foo" member variable to 5. local example = example_c.new(5)
-- Overwrite the "foo" member variable to 10. example.foo = 10
-- Prints 10. print(example.foo) </syntaxhighlight>