Scribd
Upload
42 views2 pages

The Only Members of

The width and height variables of the Rectangle class are private, so they can only be accessed by member functions of the class like set_values(). This example defines the set_values() function outside of the class declaration, while area() is defined inside. Both functions can access the private width and height since they are class members. Multiple Rectangle objects can be declared since Rectangle is a user-defined type.

Uploaded by

icul1
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
42 views2 pages

The Only Members of

The width and height variables of the Rectangle class are private, so they can only be accessed by member functions of the class like set_values(). This example defines the set_values() function outside of the class declaration, while area() is defined inside. Both functions can access the private width and height since they are class members. Multiple Rectangle objects can be declared since Rectangle is a user-defined type.

Uploaded by

icul1
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
You are on page 1/ 2

The only members of rect that cannot be accessed from outside the class are width and height,

since they have private access and they can only be referred to from within other members of
that same class.

Here is the complete example of class Rectangle:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
// classes example
#include <iostream>
using namespace std;

class Rectangle {
int width, height;
public:
void set_values (int,int);
int area() {return width*height;}
};

void Rectangle::set_values (int x, int y) {
width = x;
height = y;
}

int main () {
Rectangle rect;
rect.set_values (3,4);
cout << "area: " << rect.area();
return 0;
}
area: 12


This example reintroduces the scope operator (::, two colons), seen in earlier chapters in
relation to namespaces. Here it is used in the definition of function set_values to define a
member of a class outside the class itself.

Notice that the definition of the member function area has been included directly within the
definition of classRectangle given its extreme simplicity. Conversely, set_values it is merely
declared with its prototype within the class, but its definition is outside it. In this outside
definition, the operator of scope (::) is used to specify that the function being defined is a
member of the class Rectangle and not a regular non-member function.

The scope operator (::) specifies the class to which the member being declared belongs,
granting exactly the same scope properties as if this function definition was directly included
within the class definition. For example, the function set_values in the previous example has
access to the variables width and height, which are private members of class Rectangle, and
thus only accessible from other members of the class, such as this.

The only difference between defining a member function completely within the class definition
or to just include its declaration in the function and define it later outside the class, is that in the
first case the function is automatically considered an inline member function by the compiler,
while in the second it is a normal (not-inline) class member function. This causes no differences
in behavior, but only on possible compiler optimizations.

Members width and height have private access (remember that if nothing else is specified, all
members of a class defined with keyword class have private access). By declaring them private,
access from outside the class is not allowed. This makes sense, since we have already defined a
member function to set values for those members within the object: the member
function set_values. Therefore, the rest of the program does not need to have direct access to
them. Perhaps in a so simple example as this, it is difficult to see how restricting access to these
variables may be useful, but in greater projects it may be very important that values cannot be
modified in an unexpected way (unexpected from the point of view of the object).

The most important property of a class is that it is a type, and as such, we can declare multiple
objects of it. For example, following with the previous example of class Rectangle, we could
have declared the object rectb in addition to object rect:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// example: one class, two objects
#include <iostream>
using namespace std;

class Rectangle {
int width, height;
public:
void set_values (int,int);
int area () {return width*height;}
};

void Rectangle::set_values (int x, int y) {
width = x;
height = y;
}

int main () {
Rectangle rect, rectb;
rect.set_values (3,4);
rectb.set_values (5,6);
cout << "rect area: " << rect.area() <<
endl;
cout << "rectb area: " << rectb.area() <<
endl;
return 0;
}
rect area: 12
rectb area: 30

You might also like