2CPP18 - Modifiers


Published on

This is an intermediate conversion course for C++, suitable for second year computing students who may have learned Java or another language in first year.

Published in: Software, Technology
1 Like
  • Be the first to comment

No Downloads
Total views
On SlideShare
From Embeds
Number of Embeds
Embeds 0
No embeds

No notes for slide

2CPP18 - Modifiers

  1. 1. C++ MODIFIERS Michael Heron
  2. 2. Introduction • Modifiers are used in C++ to change default behaviour of functions and variables. • Powerful tools, but to be used with caution. • In this lecture we are going to talk about the way in which some of these work. • You’ve already seen some of them. • Public • Private • Both of these are modifiers for visibility
  3. 3. Static • Static methods and attributes are a common part of C# and Java • They indicate that the function or attribute belongs to a class rather than an object. • Each object that is instantiated makes use of the same static variables. • Change it on object, and you change it in all of them. • Only one copy of a static field is ever created, • All objects get their own bit of memory for everything else. • instance variables
  4. 4. Static • Static methods similarly are methods that belong to a class. • They do not require the context of an object in order to be used. • Often used to provide ‘utility methods’ that do not require object instantiation. • Integer.parseInt for example • Must indicate the method to be called by the class name. • Not an object name.
  5. 5. Static • Static methods are limited. • They can only make use of other static methods and static variables. • In Java the main method is a static method. • It should serve to bootstrap the program by instantiating the appropriate objects. • Programming around this can be awkward. • You may have seen this yourself in previous years.
  6. 6. Static in C++ • Static in C++ works conceptually identically. • Minor variations • Use the scope resolution operator to access static methods in a class. • Static variables cannot be set an initial value in a class declaration. • Must be done in the accompanying CPP file.
  7. 7. Static Example class Account { private: int balance; int overdraft; static float interest_rate; public: int query_balance(); void set_balance (int); int query_overdraft(); void set_overdraft (int); float query_interest_rate(); };
  8. 8. Static Example #include "Account.h" #include <iostream> #include <fstream> using namespace std; float Account::interest_rate = 0.05; void Account::set_balance (int v) { balance = v; } int Account::query_balance() { return balance; } void Account::set_overdraft (int v) { overdraft = v; } int Account::query_overdraft() { return overdraft; } float Account::query_interest_rate() { return interest_rate; }
  9. 9. Static • Instance methods can make use of static fields. • Not a great benefit • Better to make the method static and call it from the class context. • No need for the overhead of object instantiation. • Can still be called as an instance method. • But no need for it to be done so.
  10. 10. Modified Example class Account { private: int balance; int overdraft; static float interest_rate; public: int query_balance(); void set_balance (int); int query_overdraft(); void set_overdraft (int); static float query_interest_rate(); };
  11. 11. Modified Example #include <iostream> #include <fstream> #include <string> #include <iomanip> #include "Account.h" using namespace std; int main() { Account *ob; ob = new Account(); cout << Account::query_interest_rate() << endl; cout << ob->query_interest_rate() << endl; return 0; }
  12. 12. Static in C++ • When the program starts, and before an objects are instantiated, all static fields are initialized. • When an object is declared, it gets copies of instance attributes. • But no copy of the static data fields. • This system is equivalent in Java and C++ and C# • Transferable concept.
  13. 13. Static in C++ • C++ also gives us a little extra somethingsomething. • We can declare static variables that are local to methods. • They get created when the method is first called. • Have visibility only to the method in which they are defined. • Destroyed when the program ends. • Not when the method ends • This is called method scope.
  14. 14. Method Scope - Without int test_static (int tmp) { int y = tmp; return y; } int main() { int ans; ans = test_static (10); cout << ans << endl; ans = test_static (12); cout << ans << endl; return 0; }
  15. 15. Method Scope - With int test_static (int tmp) { int y = tmp; return y; } int main() { int ans; ans = test_static (10); cout << ans << endl; ans = test_static (12); cout << ans << endl; return 0; }
  16. 16. Const • One of the most useful modifiers we have available is the const modifier. • It lets us deal with some of the problems caused by relentless pointer passing. • It’s also one of the messiest • It compensates for missing language features. • It has several key roles in an object oriented program.
  17. 17. Const • First and simplest use is to declare a constant, non- changing value. • Declare something as constant so it cannot be changed. • Works much like a define in terms of where it is used. • However, it is syntactically interpreted by the compiler. • Defines just get search and replaced into your code.
  18. 18. Const • const int num = 20; • Attempting to change this after it has been defined will result in a compile time error. • Can be used to make sure there are no side-effects when working with shared, global variables. • Or class-wide variables. • It also works with pointers. • But in two different ways. • const int* blah; • Pointer to a constant integer • int *const blah; • Constant pointer to an integer.
  19. 19. Const • Can also use const to indicate a return type in a function. • Indicates to the compiler that the return value of a function should never be altered. • Returning a constant pointer is a good way to ensure fidelity of memory. • You can’t change the value of the pointer once it comes out of the function.
  20. 20. ++OUT OF CHEESE ERROR++ using namespace std; const int *memory_const (int x) { return &x; } int main() { int *ptr; int y = 10; ptr = memory_const (10); ptr = &y; return 0; }
  21. 21. Const in Parameters • We can also use const in parameter passing. • Lets us have pass by reference but also ensures we can’t change the values sent in. const int *memory_const (const int x) { x = 20; return &x; }
  22. 22. Const in Object Orientation • We can use const in methods of objects to bar them from editing instance variables. • One of the features of class-wide scope is that any method with appropriate visibility can impact on any attribute. • By adding const to a method declaration, we prohibit it from accessing method attributes. • We saw this when we looked at pure virtual methods.
  23. 23. Const and Virtual Methods • When we talked about virtual methods, we used the following format: • void function() const = 0; • And then to override, we use the following: • void function() const • This is a precautionary technique. • The const may be omitted in both conditions. • This is often used to protect from careless side-effects.