Distributed Real-Time Control Systems. Chapter 4 Very Basics of C++

Size: px

Start display at page:

Download "Distributed Real-Time Control Systems. Chapter 4 Very Basics of C++"

Ashlee Watkins
5 years ago
Views:

1 Distributed Real-Time Control Systems Chapter 4 Very Basics of C++ 1

2 Bibliography Online Covers C

3 What is C++? A computer language with object oriented programming capabilities. Invented by Bjarne Stroustroup, at the AT&T Bell Labs in the early 80 s. Derived from C. Originally a C++ to C converter. Complements the C syntax with many new features to give more flexibility and improve compile time error checking. Most existing C code compiles in a C++ compiler with few adaptations. Compatible with most C libraries and development tools. 3

4 Why C++ for Real-Time Systems? Designed for run-time efficiency. Object oriented: encapsulation, reusability, etc Many libraries available. Primitives for low level access to hardware/software resources. Can use most existing legacy C code. Most hardware devices provide programming interfaces to C/C++. 4

5 C/C++ build system header file C/C++ is a compiled language: compile + link Object (binary) files can be generated by user compiled files or supplied by libraries. Compilers/linkers exist for the vast majority of platforms. On linux machines: g++ Integrated Development Environments (IDE s) simplify development. E.g. Arduino IDE, Clion, Microsoft Visual Studio, Eclipse, Code blocks, etc 5

6 C/C++ Language Components Core Language + Standard Libraries Core Language Components: Built in types (e.g. int, char, float), operators (e.g. +, &&, >>) and control structures (e.g. for, while, if) Mechanisms for defining new functions, new types, new operators. Libraries: I/O operations (console, files) Strings Containers (e.g. vector, map) Algorithms (search, sort) Threads and Synchronization Time and Random numbers Etc 6

7 C++ Types C++ is a strongly typed language: - Every variable has a type that specifies what can be done with it. - New standards constantly improve type safe programming. C++ is a statically typed language: - The compiler must know the type of each variable Fundamental Types: bool // Boolean, possible values are true and false char // character, for example, 'a', ' z', and '9 int // integer, for example, 1, 42, and 1066 double // double-precision floating-point number, for example, 3.14 and Size of types depends on computer architecture: - use sizeof operator to obtain the right size: e.g. sizeof(int) 7

8 C++ Initialization of Variables C initialization double d1 = 2.3; The first two forms are equivalent. C++ initialization double d2 = 2.3; double d2 (2.3); double d2 2.3; The latter is preferred because it prevents implicit type conversion: int i1 = 7.2; // i1 becomes 7 int i2 7.2; int i3 = 7.2; // error: floating-point to integer conversion (narrowing) // error: floating-point to integer conversion (the = is redundant) 8

9 C++ Automatic Initialization New feature on C++ 11 If the type of the variable can be deduced automatically by the compiler, you can use keywork auto auto b = true; auto ch = 'x'; auto i = 123; auto d = 1.2; auto z = sqrt(y); // a bool // a char // an int // a double // z has the type of whatever sqrt(y) returns 9

10 C++ Operators This is identical to C Arithmetic Operators x + y // plus +x // unary plus x y // minus x // unary minus x * y // multiply x / y // divide x % y // remainder (modulus) Arithmetic Operators (inplace) x += y // x=x+y ++x // increment: x = x+1 x = y // x=x-y x // decrement: x = x-1 x *= y // scaling: x = x*y x /= y // scaling: x = x/y x %= y // x=x%y Relational Operators x == y // equal x!= y // not equal x < y // less than x > y // greater than x <= y // less than or equal x >= y // greater than or equal Logical Operators x && y // logical and x y // logical or x & y // bitwise and x y // bitwise or x ^ y // bitwise xor x >> a // left shift x << a // right shift 10

11 C++ Hello World FILE hello.cpp //the Hello World in c++ #include <iostream> // in C would be #include<stdio.h> int main() std::cout << Hello World << std::endl; //in C would be printf( Hello World\n ); On linux: - Compile with: g++ hello.cpp o hello - Run with:./hello // - line comment <iostream> - Standard library for I/O cout - object for console output, of type ostream defined in the standard library. std:: - specifies that object cout is to be found in the standard library << - operator of the type ostream that writes the right argument into the left argument. std::endl is the new line command; 11

12 Object Oriented Programming One of the the main features of C++. Objects are encapsulations of properties (variables, data) and related behavior (methods, functions) Modularity and scope. Objects are accessible from the outside through a well defined interface. Flexibility and reusability. Object Object member data Object member functions Interface 12

13 Classes Specify properties and behaviors of objects. Expanded concept of data structure: Data + Functions class class_name //declaration access_specifier_1: member1; access_specifier_2: member2;... object_names; object_names are optional names for objects to be created immediately after the class declaration. Access specifiers can be private, public or protected. private members of a class are accessible only from within other members of the same class or from their friends. protected members are accessible from members of their same class and from their friends, but also from members of their derived classes. public members are accessible from anywhere where the object is visible. 13

14 Hello World with Objects FILE hello1.h Class Definition FILE hello1.cpp Class Use FILE main_hello1.cpp #ifndef HELLO1_H #define HELLO1_H //class declaration class Hello1 private: int id; //data public: void run(); //function void set_id(int); ; #endif //HELLO1_H #include hello1.h #include <iostream> using namespace std; //class implementation void Hello1::set_id(int v) if(v>0) //check valid args id = v; else id = 1; void Hello1::run() cout<< Hello <<id<<endl; #include hello1.h #include <stdio.h> //getchar int main() // declare a local object Hello1 obj; // invoke object methods obj.set_id(1); obj.run(); // pause getchar(); // obj is destroyed here. Compile with: g++ -I. hello1.cpp main_hello1.cpp o hello1 14

15 Comments Directives #ifndef, #define, #endif prevent multiple declarations of the contents of the header file. The member access operator (.) is the same as in C structs. Scope operator (::) selects the class of the function to be used - different classes may have the same names for members. Functions run and set_id are public so can be accessed from the outside (in main()). Command using namespace std allows the use of objects from std without the prefix std::. In function declarations, parameter names can be omitted. Member data id is private : cannot be accessed out of the class, i.e. a compiler error is issued if one writes: obj1.id = 4; C++ can use C libraries, e.g. stdio.h Object obj1 is defined in the local memory of main(). When main exits the object is automatically destroyed. Compiler switch -I sets the folder where to find header files. In this case the current folder ( /. ) 15

16 Arduino (AVR) C++ The Arduino files (sketches) have extension.ino and use a subset of the C++ language. //Hello.ino void setup() int counter = 0; int time_delay = 1000; //miliseconds // initialize serial comms to host arduino library Serial.begin(9600); delay function from the Arduino library Serial object from the Arduino library Automatically included void loop() Serial.print( Hello World ); Serial.println(++counter); // print rate to serial monitor delay(time_delay); // wait duration 16

17 A more interesting example const int analoginpin = A0; // Analog input pin that the potentiometer is attached to const int analogoutpin = 9; // Analog output pin that the LED is attached to int sensorvalue = 0; // value read from the pot int outputvalue = 0; // value output to the PWM (analog out) void setup() Serial.begin(9600); // initialize serial communications at 9600 bps void loop() sensorvalue = analogread(analoginpin); // read the analog in value outputvalue = map(sensorvalue, 0, 1023, 0, 255); // map it to the range of the output analogwrite(analogoutpin, outputvalue); // change the analog out value // print the results to the Serial Monitor: Serial.print("sensor = "); Serial.print(sensorValue); Serial.print("\t output = "); Serial.println(outputValue); delay(2); // wait 2 milliseconds before the next loop for the //analog-to-digital converter to settle after the last reading 17

18 Arduino Serial Library if (Serial) available() availableforwrite() begin() end() find() finduntil() flush() parsefloat() parseint() peek() print() println() read() readbytes() readbytesuntil() readstring() readstringuntil() settimeout() write() serialevent() 18

19 Arduino (AVR) Build Process The Arduino IDE uses a specific build process. sketch1.ino.cpp #include <Arduino.h> Arduino Libraries sketch2.ino int main() setup(); for(;;) loop(); avr-g++ +.hex sketchn.ino 19

20 Arduino Other Libraries EEPROM - reading and writing to "permanent" storage. Ethernet / Ethernet 2 - for connecting to the internet using the Arduino Ethernet Shield, Arduino Ethernet Shield 2 and Arduino Leonardo ETH. Firmata - for communicating with applications on the computer using a standard serial protocol. GSM - for connecting to a GSM/GRPS network with the GSM shield. LiquidCrystal - for controlling liquid crystal displays (LCDs). SD - for reading and writing SD cards. Servo - for controlling servo motors. SPI - for communicating with devices using the Serial Peripheral Interface (SPI) Bus. SoftwareSerial - for serial communication on any digital pins. Version 1.0 and later of Arduino incorporate Mikal Hart's NewSoftSerial library as SoftwareSerial. Stepper - for controlling stepper motors. TFT - for drawing text, images, and shapes on the Arduino TFT screen. WiFi - for connecting to the internet using the Arduino WiFi shield. Wire - Two Wire Interface (TWI/I2C) for sending and receiving data over a net of devices or sensors. 20

21 C++ Scopes //LOCAL SCOPE int calc() double y=2; for(int i=0;i++;i<10) //statement scope y *= 2; //local scope for x double x = y; if ( x == 64) break; //end local scope for x y*=2*x; //error: x out of scope y+= i; //OK statement scope for i return i; //error: i is out of scope //FUNCTION PROTOTYPE SCOPE int func1(int i, double x, char* x); //error: conflicting declaration //FUNCTION SCOPE void funct2(int i) // i visible double y; // i and y visible y = i; // i and y visible double x = y; // i, y and x visible //CLASS SCOPE class A // x and i in class scope public: int i; A(double y) x=y;; //y in func. protot. scope protected: double x; 21

22 Scopes Hiding int x; void f() int x; x = 1; x = 3; // global x // local x hides global x // assign to local x int x; // hides first local x x = 2; // assign to second local x // assign to first local x int x; void f2() int x = 1; //local x hides global x ::x = 2; //assign to global x x = 2; //assign to local x //... 22

23 Global Namespace Scope Global scope or global namespace scope is the outermost namespace scope of a program, in which objects, functions, types and templates can be defined. A name has global namespace scope if the identifier's declaration appears outside of all blocks, namespaces, and classes. A name with global scope begins right after its declaration until the end of the translation unit. Definition: Translation unit - A source file and all included headers. A user-defined namespace can be nested within the global scope using namespace definitions 23

24 Namespaces Names of functions, variables, classes are frequently repeated in code from different authors. Example:Two developers, John and Paul, define a function called newtonmethod. How to use both functions in the same program? Namespaces encapsulate code from the same (group of) developer(s) in order to prevent name clashes. //john.h namespace JohnFunctions double newtonmethod(double x0); //paul.h namespace PaulFunctions double newtonmethod(double init); 24

25 Namespaces Now we can use both functions on the same program: If there are no ambiguities, we can use the keyword using to simplify syntax: #include john.h #include paul.h int main() double x = 0, j, p; j = JohnFunctions::newtonmethod(x); p = PaulFunctions::newtonmethod(x); #include john.h using namespace JohnFunctions; int main() double x = 0, j; j = newtonmethod(x); //from John 25

26 Inline functions Function calls have overhead: Copy arguments to the stack Save the return address Save return values For small functions, the overhead can be significant. inline suggests the compiler to copy the function code to where it is called, instead of doing a function call. inline int func(a,b) return (a+1)*b; int main() int x = 3, y = 4, w, z; z = func(x,y); w = func(x,z); int main() int x = 3, y = 4, w, z; z = (x+1)*y; w = (x+1)*z; 26

27 Inline vs Macros Inlines are like macros but behave like functions: Type checking Clear rules for argument passing and return. Check the problem with the following code? How to solve it? #define MYMACRO(x) ((x+1)*(x+2)) int main() int a = 2; MYMACRO(++a); CAVEATS Because the function code is replicated everywhere it is called, this may result in large increases in program size. Inlines should be reserved for small functions. The compiler may decide not to inline a function, if it is too complex. 27

28 Automatic inlines Class member functions are automatic inlines if implemented at declaration time (in-situ). class A public: int id; //automatic inlines A(int i) id = i ; int incr() return id++; Class member function inlines, if not defined in-situ, must be defined in the same file as the class declaration. class A public: int id; A(int); int incr(); //not automatic inlines inline A::A(int i) id = i; inline int A::incr() return id++; 28

Distributed Real-Time Control Systems. Lecture 17 C++ Programming Intro to C++ Objects and Classes

Distributed Real-Time Control Systems Lecture 17 C++ Programming Intro to C++ Objects and Classes 1 Bibliography Classical References Covers C++ 11 2 What is C++? A computer language with object oriented