C++ CLASSES C/C++ ADVANCED PROGRAMMING

Transcription

1 C++ CLASSES C/C++ ADVANCED PROGRAMMING

2 GOAL OF THIS LECTURE C++ classes Dr. Juan J. Durillo 2

3 (C++) CLASSES: BASIC CONCEPTS Fundamentals of classes data abstraction data encapsulation Data abstraction: separation interface/implementation interface: operations that customers of the class can execute implementation: class data members + function bodies (interface implementation and internal ones) Encapsulation enforces the separation of a class interface and implementation users of the class can use the interface but they have no access to the implementation A class (using data abstraction and encapsulation) defines an abstract data type The class designer worries about how the class is implemented Clients of the class only need to know only how the abstract type works (defined by the interface) Dr. Juan J. Durillo 3

4 (C++) CLASSES: BASIC CONCEPTS Abstract data types are defined by their interface rather than their data Class designers decide which methods are visible to clients which methods are intended for the implementation of the class data types used to provide that implementation The interface of a class consist of its public members Dr. Juan J. Durillo 4

5 C++ CLASSES: BASICS Basic class definition struct myclass { string value() const; myclass& combine(const Sales_data&); double price() const; }; Note as in java, this can be used to refer to the current object the type of this is a const pointer A reference to this can be returned by using return *this Classes provide member functions and operators Member functions are declared similarly to ordinary functions must be declared inside the class may be defined inside the class itself or outside the class body Note examples of operators can be +,=, <<, >>, or += Note functions defined in the class are implicitly inline Dr. Juan J. Durillo 5

6 THE STRUCT AND CLASS KEYWORDS Within a class body we use different access specifiers Members declared after a public specifier are accessible to all parts of the program Members declared after a private specifier are accessible to the member functions of the class, but are not accessible to code that uses the class There is no restriction on how many times a specifier can appear in the body of a class Classes can be declared with the keywords struct or class struct: all the members declared before the first specifier are publics class: all the members declared before the first specifier are private 6

7 THE FRIEND ACCESS SPECIFIER A class can allow another class or function to access its non-public members by tagging that class or function with the friend specifier A class makes a function its friend by including a declaration for that function preceded by the keyword friend Friends declarations may appear only inside a class declaration anywhere in the class, but not outside they are not member of the class and are not affected by the access control of the section in which they are declared Dr. Juan J. Durillo 7

8 THE FRIEND ACCESS MODIFIER Declaring a friend class struct myclass { friend class OtherClass; }; Declaring a friend function struct myclass { friend void OtherClass::clear(); // declaring the function clear as friend }; Note The right sequence of steps are: 1. Define OtherClass and declare (but not define) clear 2. Include a friend member for clear 3. Define clear Although they share a common name, overloaded versions of a function are still different functions Different overloaded functions variants would require different friend declarations Dr. Juan J. Durillo 8

9 C++ CLASSES: BASICS Methods may include the keyword const following the parameter list (see example in previous slide) purpose: to modify the type of the implicit this pointer Explanation this would be of the type myclass *const (in the example before), i.e., a const pointer A pointer to a non const object cannot point to a const object (because we would be able to modify the object then) It would not make sense that this would point to a const objects (const myclass* const in the example before) To avoid that the keyword const transforms the this for that call into the type const myclass*const These methods cannot modify the object they work on These methods are known as const member methods Note objects that are const, and references or pointers to const objects, may call only const member functions Dr. Juan J. Durillo 9

10 MUTABLE DATA MEMBER They keyword mutable allows to modify data members inside const member functions A const member function may change a mutable data member (actually any member function can change its value) A mutable data member is never const, even when it is a member of const object Dr. Juan J. Durillo 10

11 CLASS SCOPE AND MEMBER FUNCTIONS A class defines a scope, where definition of the member functions are nested within When a function member is defined outside a class The return type, parameter list, and name must match the declaration in the class body If the member was declared as a const member function, then the definition must also specify const after the parameter list The name of a member defined outside a class must include the name of the class of which it is a member Dr. Juan J. Durillo 11

12 CLASSES LIFECYCLE There are a few basic operations that any class is likely to need to support Initialization Cleaning up memory or other resources Copying itself Assigning it Moving? Dr. Juan J. Durillo 12

13 CREATING INSTANCES OF A CLASS Dr. Juan J. Durillo 13

14 CONSTRUCTORS Each class defines how objects of its type can be created special member functions known as constructors same name as the class, have no return type, and have a parameter list a class may have multiple constructors which differ in the number of type parameters Constructors role: to initialize data members of a class object Constructors cannot be declared as const during the initialization of an object the object is not const Note this does not mean that you cannot create a const object! Actually you can (and sometimes you must!) 14

15 (SYNTHESIZED) DEFAULT CONSTRUCTOR The default constructor is one that uses no parameters (empty parameter list) A constructor defining default values for all its parameters is also a default constructor When no constructor is provided, the compiler will synthesize a default constructor If a class defines a constructor with a parameter, that class have no default constructor unless a default constructor is explicitly defined The synthesized default constructor initializes each class members as follows If the type to initialize has a in-class initializer, use it Otherwise, default-initialize each of the member Dr. Juan J. Durillo 15

16 SYNTHESIZED DEFAULT CONSTRUCTOR Only fairly simple classes should rely on the synthesized default constructor The synthesized constructor may not always do the right thing the class designer knows better than the compiler how she wants the object to be initialized Yet sometimes it may do the right thing, and we can tell the compiler to generate it (C++11) struct myclass { myclass() = default; myclass(const std::string &s) : message(s) {} }; Sometimes the compiler is unable to generate a default constructor E.g., the class has a member of a particular class type with no default constructor Dr. Juan J. Durillo 16

17 EXPLICIT CALLS TO THE DEFAULT CONSTRUCTOR The default constructor takes an empty list of parameters; however, the following declaration is erroneous Sales_data obj(); Although it compiles, it declares a function, it does not create an object The declared function takes no arguments and returns a object of the class type The correct way of defining an object that uses the default constructor for initialization is to leave off the trailing empty parenthesis Sales_data obj Dr. Juan J. Durillo 17

18 THE DEFAULT CONSTRUCTOR ROLE Is used whenever an object is default or value initialized Default initialization occurs when we define non static variables or array at block scope without initializers a class has member of a class type, its default constructor is called by the synthesized default constructor a class member is not explicitly initialized in a constructor initializer list Value initialization occurs when array is initialized when we provide fewer initializers than the size of the array we define a local static object without an initializer we explicitly request a value initialization by writing an expression of the form T(), being T a type name Classes must have a default constructor in order to be used in these contexts Dr. Juan J. Durillo 18

19 CONSTRUCTOR INITIALIZATION LIST After the parameter list, a constructor sometimes includes a comma-separated list starting with a colon (:) that comma-separated list is known as the constructor initializer list The constructor initializer list is used to give the initial value to one or more of the object members Each member of the list is a member name followed by the desired initial value for that member in parenthesis (or curly braces) Members ignored by the initializer list are initialized using the in-class value or default initializer if no in class initializer exists Note Constructors should not override in-class initializers except to use a different initial value; if we do not explicitly initialize a member using the constructor initializer list, that member is default initialized before the method start executing. If that member is const, then we cannot assign any other value to that member: Our single chance is to use the constructor initializer list Dr. Juan J. Durillo 19

20 CONSTRUCTOR INITIALIZATION LIST A constructor initializer list specifies only the values to initialize the members, not the order in which those initializations are performed Members are initialized in the order in which they are declared i.e., the first declared member is initialized first, the second next, and so on Although the order of initialization does not matter in many occasions, when a member is initialized in terms of another, the order in which members are initialized is crucially important class X { int i; int j; public: X(int val) : j(val), i(j) {} //undefined: i is initialized before j }; Dr. Juan J. Durillo 20

21 DELEGATING CONSTRUCTORS Since C++11 standard, a constructor initializer list can delegate on another constructor Delegating constructor A delegating constructor uses another constructor from its own class to initialize the object it is said to delegate some (or all) of its work to this other constructor In a delegating constructor, the member initializer list has a single entry that is the name of the class itself followed by a parenthesized list of arguments The argument list must match the list of arguments of another constructor of this class class Sales_data{ public: Sales_data():Sales_data(,0,0) {} }; Dr. Juan J. Durillo 21

22 COPYING, ASSIGNING, AND DESTROYING OBJECTS Classes also control what happens when we copy, assign, or destroy objects of that class Objects are copied in several contexts e.g., when we initialize a variable or when we pass or return an object by value Objects are assigned when we use the assignation operator in anything different than a declaration Objects are destroyed when the class ceases to exist e.g., when a local object is destroyed or exit from the block when it was created e.g., objects in a vector are destroyed when the vector is destroyed If we do not define operations for copying, assigning and destroying an object, the compiler will synthesize them for us In many cases synthesized versions of these operations will do the work for us, some classes, specially if the use dynamic memory, should not rely however on the synthesized versions 22

23 CLASSES DEFINE A TYPE A class can define its own local name for types Control access mechanisms as for any other member apply class myclass { public: typedef std::string::size_type pos; private: pos cursor = 0; }; Note Members that define a type must appear before they are used (as a result type members usually appear at the beginning of the class) class myclass { public: using pos = std::string::size_type; }; Note We define pos in the public part because we want users to use that name 23

24 INLINE AND OVERLOADED MEMBER FUNCTIONS Inline members Member functions defined inside the class are automatically inline Members functions defined outside the class can also be explicitly defined as inline By declaring them as inline By using inline in the function definition Overloaded member functions Member functions can be overloaded as long as the functions differ by the number and/or type of parameters Dr. Juan J. Durillo 24

25 FUNCTIONS THAT RETURN *THIS A member function may return the object to which the function is applied A sequence of actions into a single expression can then execute on the same object myclass.setvalues(4,0).setvalue( # ) ; setvalues and setvalue have to be defined as returning MyClass & Have setvalues returned a non-reference type, the call to setvalue would have been done in a temporary copy instead of the object itself Dr. Juan J. Durillo 25

26 OVERLOADING BASED ON CONST We can overload a member function based on whether it is const The non const version won t be available for non const objects The const member functions will only apply to const objects Dr. Juan J. Durillo 26

27 CLASS DECLARATION A class can be declared without defining it class MyClass; // class is declared A declared but undefined class introduces the name of that class as a Type It can be used to define pointers or references to such types and to declare (not define) classes returning or using that type A class must be however defined (not only declared) before writing code that uses that class, and also before a reference or pointer is used to access to that class Dr. Juan J. Durillo 27

28 CLASS SCOPE From outside a class scope, data and function members may be accessed through an object, a reference, or a pointer using a member access operator Type members from a class are accessed using the scope operator MyClass::pos ht = 24, wd = 80; // use the pos type defined by MyClass MyClass scr(ht,wd, ); MyClass *p = &scr; char c = src.get(); // fetches the get member from the object src c = p->get(); // fetches the get member from the object to which p points Members defined outside a class must use the scope parameter to refer to members of that class Dr. Juan J. Durillo 28

29 NAME LOOKUP AND CLASS SCOPE Name LookUp is relatively straightforward Look for a declaration of the name within the block in which the name was used (only names declared before are considered) If the name is not found, look in the enclosing scope(s) If no declaration is found, then the program is in error status Inside member functions defined within the class First, the member declarations are compiled Function bodies are compiled only after the entire class has been seen Note This procedure is called two-phase compilation, and is the one used to compile classes Dr. Juan J. Durillo 29

30 NAME LOOKUP AND CLASS SCOPE The two-phases compilation process applies only to names used in the body of a member function Names used in declarations, return and parameter lists, must be seen before they are used If a member declaration uses a name that has not been seen yet within the class, the compiler will look for that name in the scope in which the class has been defined typedef double Money; string bal; class Account { Money balance() { return bal;} private: Money bal; }; Note Money and bal in function balance are resolve in different ways Dr. Juan J. Durillo 30

31 NAME LOOKUP AND CLASS SCOPE A inner scope can redefine a name from an outer scope even if that name has been already used in the inner scope In a class, if a member uses a name from an outer scope and that name is a type, then the class must not subsequently define the name typedef double Money; class Account { public: Money balance() { return bal;} // uses Money from the outer scope private: typedef long long Money; // error cannot redefine Money!!! }; Note Remember that definition of type names usually should appear at the beginning of a class. That way nay member that uses that type will be seen after the type name has already been defined Dr. Juan J. Durillo 31

32 NAME LOOKUP AND CLASS SCOPE Names used in the body of member functions are resolved as follows Look for a declaration of the name inside the member function (as usual, only declarations in the function body that precede the use of the name are considered) If the declaration is not found before within the member function, look for a declaration inside the class All the member of the class are considered If a declaration for the name is not found in the class, look for a declaration that is in scope before the member function definition Dr. Juan J. Durillo 32

33 IMPLICIT CLASS-TYPE CONVERSIONS A constructor that can be called with a single argument defines an implicit conversion to a class type Have MyClass a constructor accepting a string as single parameter a string, and a member??? combines(myclass object) we can do string null_object = whatever string ; item.combine(null_object); // automatically converts null_object to an object of MyClass Only one class-type conversion is allowed item.combine( whatever string ); // error: why is this an error? We can prevent the implicit use of a constructor by declaring the constructor explicit Constructors requiring more arguments are not used to perform an implicit conversion Dr. Juan J. Durillo 33

34 AGGREGATE CLASSES An aggregate class gives users direct access to its members and has special initialization syntax A class is aggregate if All of its data members are public It does not define any constructor It has no in-class initializers It has no base classes or virtual functions, which are class-related to object oriented Aggregate classes can be initialized by providing a brace list of member initializers They should appear in the order in declaration order of the data members Data val1 = {0, Anna }; // ok Data val2 = { Anna, 0}; // error // Example of aggregate class struct Data { int ival; string s; }; Dr. Juan J. Durillo 34

35 STATIC CLASS MEMBERS A static member is a member associated with the class rather than with individual objects declared by preceding the member the keyword static Static members can be accessed directly through the scope operator also through an object, reference or pointer of the class type Member functions can use static members directly, without the scope operator static member class are declared within the class and are usually defined outside outside we do not need to repeat the keyword static Even if you initialize a member within the class declaration, you may need to define the member outside the class Doing it always is a good programming practice Dr. Juan J. Durillo 35