Your SlideShare is downloading. ×
0
2CPP18 - Modifiers
2CPP18 - Modifiers
2CPP18 - Modifiers
2CPP18 - Modifiers
2CPP18 - Modifiers
2CPP18 - Modifiers
2CPP18 - Modifiers
2CPP18 - Modifiers
2CPP18 - Modifiers
2CPP18 - Modifiers
2CPP18 - Modifiers
2CPP18 - Modifiers
2CPP18 - Modifiers
2CPP18 - Modifiers
2CPP18 - Modifiers
2CPP18 - Modifiers
2CPP18 - Modifiers
2CPP18 - Modifiers
2CPP18 - Modifiers
2CPP18 - Modifiers
2CPP18 - Modifiers
2CPP18 - Modifiers
2CPP18 - Modifiers
Upcoming SlideShare
Loading in...5
×

Thanks for flagging this SlideShare!

Oops! An error has occurred.

×
Saving this for later? Get the SlideShare app to save on your phone or tablet. Read anywhere, anytime – even offline.
Text the download link to your phone
Standard text messaging rates apply

2CPP18 - Modifiers

81

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.

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
0 Comments
0 Likes
Statistics
Notes
  • Be the first to comment

  • Be the first to like this

No Downloads
Views
Total Views
81
On Slideshare
0
From Embeds
0
Number of Embeds
0
Actions
Shares
0
Downloads
3
Comments
0
Likes
0
Embeds 0
No embeds

Report content
Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
No notes for slide

Transcript

  • 1. C++ MODIFIERS Michael Heron
  • 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. ++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. 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. 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. 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.

×