1 / 21

Functions

Learn about different parameter transmission modes in C++ functions, including pass by value, pass by reference, and pass by const reference. See examples and understand the benefits of each mode.

johnrichard
Download Presentation

Functions

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Functions Sujana Jyothi C++ Workshop Day 2

  2. Functions3 Parameter transmission modes • pass by value (default) • pass by reference (&) • pass by const reference (const &) local copy pass the address good for big structures

  3. FunctionsExample of Pass by value int sqr(int x) { } The compiler makes a local copy!

  4. The Swap Function void swap (int x, int y) { // Create a temporary variable int temp; temp = x; The swap doesn’t happen! x = y; y = temp; Why? }

  5. Passing values by reference • C/C++ passes parameters by value, i.e. a copy of the variable is passed to the function, not the actual value itself. • C++ can pass the actual variables themselves - known as passing parameters by reference. • To pass a parameter by reference we place & between the parameters type name and the parameter tag.

  6. The New Swap Function void swap(int& x, int& y) { // Create a temporary variable int temp; temp = x; x = y; y = temp; }

  7. FunctionsExample of Pass by reference void swap(int & x, int & y) { } Address Must pass by reference!

  8. FunctionsPass by constant reference • Makes sense with large structures or objects • const & We'll use it when we make objects.

  9. Arrays are passed by reference const int MAX = 100; void init(int a[], int x) { for (int i = 0, i < MAX; ++i) a[i] = rand() % 100; // remainder x = 99; } main() { int a[MAX], x = 7; init(a, x); cout << a[0] << ‘\t’ << x << endl; }

  10. Functions: Types of arguments and return values • Types of return values • conversion rules also apply to return-statementsint g(double x, double y) { return x * x - y * y + 1;} • the value returned is int and truncation takes place It would be better to explicitly acknowledge this with a castint g(double x, double y) { return int (x * x - y * y + 1);}

  11. Functions: initialization #include <iostream> void f() { static int i=1; std::cout << i++ << std::endl; } int main() { f(); f(); return 0; } What's the output?

  12. A static variable can be used as a flag void f() { static bool first_time = true; if (first_time) { cout << “f called for the first time\n”; first_time = false; // false } cout << “f called (every time)\n”; } static constanst can also be used in classes

  13. What is the output of the following program segment when function ‘f1’ is invoked ???? What is the output of the following program segment when function ‘f2’ is called twice ???? void f1() { int x=5; f2(x); cout << x <<endl; } void f2( int x ) { x+=5; cout << x << endl; } void f2() { static int x=0; x++; cout << x << endl; }

  14. Functions: initialization • Default arguments • C++ allows a function to be called with fewer arguments than there are parameters • Once a parameter is initialized, all subsequent parameters must also be initialized void f(int i, float x=0; char ch=‘A’) { .. }

  15. Functions: initialization void f(int i, float x=0; char ch=‘A’) { ... } ... f(5, 1.23, ‘E’); f(5, 1.23); // equivalent to f(5,1.23,‘A’); f(5); // equivalent to f(5,0,‘A’);

  16. Function overloading • two or more functions with the same name • The number or types of parameters must differ: void writenum(int i) { std::cout “i is “ << << i << std::endl;}void writenum(float x) { std::cout << “x is: “ << x << std::endl;}

  17. Functions: overloading int g(int n) { ...}float g(int n) { ...} NO!

  18. Functions: References as return values • A value can be returned from a function using any of the 3 transmission modes. • This is especially important when passing objects. Pass by value makes a copy!

  19. Functions: Inline functions and macros • A function call causes • a jump to a separate and unique code segment • the passing and returning of arguments and function values • saving the state • Inline functions cause • no jump or parameter passing • no state saving • duplication of the code segment in place of the function call

  20. Which is safer: macro or inline?which faster? which smaller? #define max(a, b) (a < b) ? a : b) inline int max(int a, int b) { return a > b ? a : b; }

  21. Use inlining judiciously • Inlining is safer, provides opportunity for compiler to optimize, frequently smaller and faster code! • overzealous inlining = code bloat ==> pathological paging, reduce instruction cache hit rate • if function body is short, inlined function may be shorter than code generated for the call • the inline directive is a compiler hint, not a command. Compilers are free to ignore

More Related