• Like
2CPP02 - C++ Primer
Upcoming SlideShare
Loading in...5
×

Thanks for flagging this SlideShare!

Oops! An error has occurred.

2CPP02 - C++ Primer

  • 41 views
Published

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
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Be the first to comment
    Be the first to like this
No Downloads

Views

Total Views
41
On SlideShare
0
From Embeds
0
Number of Embeds
0

Actions

Shares
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++ PRIMER Michael Heron
  • 2. Introduction • It’s my understanding that you all learned Java as your main language last year. • That puts you in a relatively good place for learning C++ • They are somewhat similar languages. • Where possible, C++ code will be related back to Java in example code. • This is not possible in all circumstances.
  • 3. Java versus C++ • The biggest differences, as far as this module is concerned, are as follow: • Java is a platform independent programming language. • C++ is not • Java is a pure object oriented language. • C++ is not • Java handles memory management transparently • C++ requires explicit memory management • Java hides the details of passing by value and reference. • C++ requires explicit handling • Java permits single inheritance only • C++ permits multiple inheritance.
  • 4. Pure OOP • Java is a pure object orientation language. • All code must belong to a class. • C++ permits a mix and match approach. • This is stylistically bad. • For this module, your C++ code should be, as far as is possible, written as if it were pure object orientation. • It is possible to have variables and functions that are not part of a class in C++. • This will be Frowned Upon
  • 5. A Simple C++ Program #include <iostream> using namespace std; int main() { cout << "Hello World!" << endl; return 1; }
  • 6. More C++ Differences • This simple C++ program highlights several differences to Java programs. • First of all, line 1: • #include <iostream> • This is known as a preprocessor directive. • Before any of your C++ code is compiled, the compiler runs a process called the preprocessor on it. • It’s essentially a very powerful search and replace routine. • The #include directive tells C++ to take the file iostream.h and include it, in its entirety, in the current file. • More on the preprocessor later.
  • 7. More C++ Differences • The second line: • using namespace std; • This is something akin to an import in Java. • It tells C++ we are going to be using the classes and methods that make up the std set (primarily this is input and output). • We begin execution from a main method, just as with a Java program. • However, in C++ this main method is never contained within a class.
  • 8. More C++ Differences • In Java we use System.out.println to print text to the console. • In C++ we make use of an IO Stream… specifically, the cout. This represents the standard output stream. It is defined in std. • The << operator is used to send data to the stream. • endl is a special symbol – it represents an end of line. • A n symbol essentially.
  • 9. Creating a C++ Project in Visual Studio • There are many development environments available for C++ development. • I myself am partial to Netbeans. • We’ll be using Visual Studio in the labs. • Start Visual Studio • Create a new C++ Project • A Win32 Console Project
  • 10. Settings • In Application Settings • Application type should be Console Application • Check the Empty Project checkbox • Or you’ll end up with lots of stuff you don’t want. • Click finish • Add a source file. • Go to the solution explorer • Right click on the project file • Add -> Add New Item • The template should be a C++ (cpp file) • Enter the filename (say, main.cpp) to get a blank file.
  • 11. C++ Syntax • Basic structures of C++ are very similar to Java. • They are both c-type languages. • The following are almost syntactically identical: • If statements • Switch statements • Variable declarations • For loops • While loops
  • 12. Some Minor Differences • While the syntax is very similar (and thus we won’t spend a lot of time discussing it), there are some minor differences. • C++ will interpret any non-zero value as true in an if or continuation condition: int blah; blah = 1; if (blah) { cout << "What Up!" << endl; }
  • 13. Some Minor Differences • Strings in C++ are declared in lower case: string bing; • Standard decimal data type is a float. • Not a double. • Booleans known as bool • Work the same way. • Non null values in conditionals evaluate as true. • They don’t have to explicitly be true or false conditions
  • 14. Some Major Differences • Functions in C++ often need to be prototyped. • This means you provide a little ‘hint’ for the compiler by stating the function signature at the top of the file. #include <iostream> using namespace std; void print_message (string); int main() { print_message ("bing"); return 1; } void print_message (string txt) { cout << txt << endl; }
  • 15. Some Major Differences • C++ programs make constant use of pointers. • These are references to areas of memory rather than discreet values. • Java does this too for non-primitive data types. • It handles it automatically. • C++ requires you to explicitly manage pointer references yourself. • Very powerful, but also an easy way to mess up a program! • We’ll talk about pointers towards the end of this lecture.
  • 16. C++ File Structure • The code in a C++ program is usually broken up into two parts. • A header file (with the suffix .h) which contains function prototypes and preprocessor directives. • A source code file (cpp) which contains the code statements. • A header file should not contain code. • A source file can (and sometimes should) contain prototypes and directives.
  • 17. The Preprocessor • Perhaps the most powerful new feature you will instantly encounter is the preprocessor. • As indicated previously, it takes on the form of a powerful, context sensitive search and replace routine. • The two most common directives are #include and #define. • #include we have already seen
  • 18. The Preprocessor • #define allows you to create a token that gets replaced with something during the first runtime pass. • In C++, these get used in the same way as static consts in a java class. • For example, in our header file we might declare the following: #define NAME“michael”
  • 19. The Preprocessor • Whenever we compile a program, the compiler does a pass over our code with the preprocessor. • Every time it sees the token NAME it will replace it with the string literal “michael”. • This allows for constant values to be set in one place and made available to entire programs provided they #include our header file.
  • 20. The Preprocessor • This occurs before any C++ syntax checking in the compiler. • You can introduce syntax errors this way. • Some directives allow for conditional inclusions • For example, the #ifdef directive sets a section of directives to be contingent on a certain token being defined. • That range is ended with an #endif • #else can be used, as in an if-else structure. • #undef can be used to undefine previous defines.
  • 21. The Preprocessor #include <iostream> #define TESTING 1 #ifdef TESTING #define TEXT "this is a test" #else #define TEXT "this is not a test" #endif using namespace std; void print_message (string); int main() { print_message (TEXT); return 1; } void print_message (string txt) { cout << txt << endl; }
  • 22. The Preprocessor • It’s not terribly important you can see why this is useful at the moment. • You should recognise what is happening though, because the preprocessor is one of the biggest differences in C++ programming. • We will be making use of the preprocessor as necessary as we go through the module material.
  • 23. Input in C++ • Text input in C++ is extremely easy to do. • Somewhat of a departure from how it is done in Java. • The cin stream is used for this. • The >> operator is used to pull information out of a stream • cin reading terminates whenever it finds a space. • It is thus fine for reading in single words and atomic data.
  • 24. Input in C++ #include <iostream> using namespace std; void print_message (int); int main() { int age; cout << "What is your age?" << endl; cin >> age; print_message (age); return 1; } void print_message (int txt) { cout << "Your age is " << txt << endl; }
  • 25. Input in C++ • For reading in lines of text with spaces, the getline function is used instead. • This takes two parameters • The input stream to use • The variable into which it should place the received information. • It returns no value. • Often getting input to work properly is a vaguely black are. • We will talk about why later.
  • 26. Pointers • Pointers represent the biggest departure from C++. • They take some getting used to, but become second nature before too long. • I am making the assumption here that you understand (in general, if not in specifics) that you understand how memory works in a computer program. • Interrupt now if I’m wrong!
  • 27. Pointers • In general, C++ passes primitive variables by value. • Functions get a copy of the data, not the data itself. • This means if you change it in one function, it one impact on the original declaration. • This is equivalent to what happens in Java. • But Java gives us limited options for changing the way that works.
  • 28. Pointers #include <iostream> using namespace std; void add_to_num (int); int main() { int num; num = 10; add_to_num (num); cout << "Number is " << num << endl; return 1; } void add_to_num (int num) { num = num + 1; }
  • 29. Pointers • In C++, we have access to two powerful operators. • &, which is the reference operator • You can literally think of this as a shorthand for ‘address of’ • *, which is the dereference operator • You can think of this as ‘value of’ • We can use this to specialise our variables.
  • 30. Pointers #include <iostream> using namespace std; void add_to_num (int*); int main() { int num; num = 10; add_to_num (&num); cout << "Number is " << num << endl; return 1; } void add_to_num (int *num) { *num = *num + 1; }
  • 31. Pointers • I only want to touch on this at the moment. • We don’t need to go into too much depth at this point, we’ll return to the topic later when it actually starts to matter. • The important thing is that you recognise these operators when you see them. • *num means ‘the value of the memory location pointed to by num’ • &num means ‘the memory location where num resides’
  • 32. Summary • C++, like Java, is a C-Type language. • It has many similarities. • It has many differences. • The key differences are: • the preprocessor • pointers • The lack of a pure OOP framework • Over the coming weeks, we’ll learn more about all of these.