1

Brief recap of the first lecture.

2

There‟s a concept in computer science called Turing completeness – basically, that if a

language has a minimum set of features (to oversimplify – the basics are having variables

that can be read and modified paired with if statements), you can implement any

algorithm in it. This means that any algorithm you can implement in one Turing

complete language you can implement in another.

This does not mean that all languages are equally suited to all tasks.

Most people in the class are aware of Python. CS115 (a pre-requisite of this course) is

now taught in it.

It‟s worth thinking about the differences between it and C++.

3

A program is a series of instructions that can be executed by a computer.

4

The underlying program that the computer runs to manage other programs (and

everything else in the computer).

This is really outside of the subject of this course; the department offers a course on

operating systems.

5

Interpreted code is read in by a program (called an interpreter), then converted to

instructions for the computer after being read, and then executed by the computer.

While interpreted code is slower than compiled code (in real world cases, around 5x

slower is a reasonable ballpark for how much slower), it has advantages – it‟s often more

portable, and usually easier to write. It also tends to have lesser consequences when the

code fails, and is easier to secure since the interpreter knows exactly what the code it‟s

running does.

Modern web development is largely done in interpreted languages (or bytecode languages,

which are something of a special case of interpreted languages, which have some of the

advantages of compiled languages) both because the performance disadvantage is harder

to see when you add in the buffer of network access time and security and reliability tend

to be more important.

6

Compiled code is compiled by a compiler.

(That may be the single worst sentence you‟ll read this year)

But anyway, your compiler takes your code, and compiles it into binary form. In this

binary form, the computer executes it directly.

Most desktop applications use compiled code.

7

Overview of tools we‟ll use in the class.

8

The IDE is the big fancy program that we use to edit code and launch the compiler.

We‟ll be using Visual Studio.

It‟s important to note that the IDE is not the compiler, linker, or debugger – it just calls

them for you and automates a lot of tasks.

And makes code prettier to look at. Which is pretty handy.

9

The compiler converts your code into binary format, something the computer can read.

10

The linker links code to other code – after the compiler finishes with the code, it‟s in a

form the computer can execute, but it‟s also going to need a lot of support code. Writing

a string to the screen seems simple, but there‟s a lot of code that has to be executed to

make it happen; the linker is what connects your function calls in your compiled code to

the implementation of those functions in the libraries.

11

We‟ll talk a lot more about this later.

The debugger is one of the most important tools for a software developer; it lets you

look at what‟s going on in your code in the middle of the program execution.

I‟ve been asked in the past what it takes to achieve expertise in C++. I‟ve said about six

thousand hours waist-deep in a debugger. A good friend of mine who manages other

programmers claims I‟m wrong, and the real number is around ten thousand. In any

case, this is a critical tool for writing programs, and is the key for pulling off complex

programs.

12

Mistaking these two is a common mistake for new programmers.

C and C++ require the use of header files to let the compiler know which functions in

libraries you can call.

This is distinct from the libraries themselves, which are binary code that the linker

connects your code to.

Using the #include preprocessor directive just adds the header file; the library itself is

handled at the linker stage.

13

And here we have the C++ hello world program.

14

Result of running this program.

15

This includes the iostream header. This allows the compiler to call functions and use

classes in the iostream header – cout and endl in the short program we just saw.

16

Function definition for main.

There must be a main function in a C++ program, and this is the standard header. It

returns an int (indicated by the “int” to the left of main) and has two arguments – we‟ll

talk about the arguments later in the class.

17

These are curly brackets. No, we don‟t have better words for them. They define a block.

Within them is the code contained in the main function.

18

This is the actual hello world.

This takes cout (console output), and sends the string literal “Hello, world” to it. Then it

sends an end of line character (endl) to the console output as well.

19

And then we return 0 – which is convention for a program that completed successfully.

20

This tells us that we‟re using the std namespace. That‟s where things like cout and endl

live; we use this to make the rest of the program a bit less verbose.

This will show up in almost all of our programs.

21

This is what the program would look like without “using namespace std;”.

Note that instead of “cout” we have “std::cout” and “std::endl” instead of “endl”.

The using namespace line lets us use these simpler forms, and so we‟ll use it in pretty

much all of our programs.

22

Hello world, again.

23

And what most of our early programs will look like – main function definition, stuff

done, then return 0.

24

These are comments – text that‟s not read by the compiler. Use them to describe what‟s

going on in the code.

The first one is a single line comment – anything on the line after the // is a comment.

The second one is a multiple line comment – anything between the /* and */ sequences

is treated as a comment, regardless of how many lines it spans.

25

26

The next program.

27

Its output.

28

The program, like all C++ programs, consists of statements.

Statements end with a semicolon.

29

These declare two constant integer variables and set their values.

Constant variables – noted by “const” in the declaration – cannot be changed after being

set.

“int” declared them as integers

“=“ sets their value.

The semicolon at the end terminates the statement.

30

This declares another integer variable, and sets it to the two earlier defined variables

multiplied.

31

And then we send it to cout (console output) again. More string literals (text between “”

pairs), and then the integer value we calculated. And another end of line character

afterwards.

32

So, we just saw some declared, but let‟s talk about it formally.

33

“const” comes first if the variable is constant, then you put the variable type (we‟ve only

seen “int” so far, but we‟ll see a lot more shortly), then the name of the variable. Then,

optionally, you can assign a value to it.

Big thing here – if you don‟t assign a value to a scalar value (which basically means a

simple numeric type), the value it holds is undefined. This isn‟t initialized to zero or

anything like that, but literally undefined – you have no way of knowing what‟s going to

be in that variable. So make a habit of assigning values when you declare variables.

34

Table listing the basic scalar types.

The bold ones at the top are the important ones for this class.

Note that the meanings are just “standard” and not exactly defined; you are unlikely to

run into a compiler that does not have 32-bit ints, but it‟s possible as that‟s not strictly

defined by the C++ standard.

35

So we‟ve got variables of multiple types, so what can we do with them?

Arithmetic!

36

Yes, it should be radius * radius * PI. Oops.

37

38

Binary operators – take two arguments (e.g., a + b):

= Assignment (sets the variable on the left to the value on the right)

+ Addition

- Subtraction * Multiplication

/ Division

% Modulo – remainder after an integer division is performed

Unary operators – take one argument (e.g., a++):

++ Increment; adds one to the variable

-- Decrement; subtracts one from the variable

39

Note on the division operator:

Most arithmetic operators will perform basically the same operation if done on ints or

floating point values (but all “promote” up to floating point values if one argument is an

int and the other a floating point value). Division works a bit differently.

If both arguments are integers, the result is an integer as well. If either is floating point,

then the result is floating point.

So:

5 / 2 == 2

5.0 / 2 == 2.5

5 / 2.0 == 2.5

5.0 / 2.0 == 2.5

Worth noting, this is a common source of mistakes – getting the wrong type of division.

40

Comparison operators

== Equivalence (tests if the two arguments are the same)

!= Nonequivalence

< Less than

> Greater than

<= Less than or equal to

>= Greater than or equal to

41

Logical operators

! Not – this is a unary operator!

&& Logical and

|| Logical or

Note! && is a different operator from &. && is logical and, & is bitwise and (which we

may go over later in class). Make sure you have the correct operator when performing

logic! There is also | which is bitwise or to be aware of.

42

These are used primarily for moving data to streams (as shown on the next slide).

They also have meanings as bitwise operators, but we won‟t see that much.

43

Insertion operators in use.

44

Yes, yes they are.

This is a common mistake, not only for new programmers but for veteran programmers

as well. It‟s a poor design decision of C++!

45

Another strange (to the modern viewer!) design decision of C/C++…

46

And some history!

47

Well, a lot of it is because it‟s based on an earlier language – C. And it‟s difficult (as in,

expensive) to switch over to a new language, so we have a ton of stuff that is in C and

C++, and it‟s awfully expensive to switch for something as relatively minor as what a

couple of operators look like…

48

But they‟re awfully easy to confuse…

49

50

This is the ancient history of computing.

The first Turing complete computer was built in 1945; in Germany by Konrad Zuse.

The first “modern” programming language (as in, something that was not direct machine

code or assembly, which is code that just serves as mnemonics for binary machine code)

was FORTRAN, which first appeared in 1957.

51

This is an IBM 704. A breakthrough computer of its era from 1954; IBM sold more than

they were expecting – all told, 123 by the time the model was discontinued. In today‟s

dollars, they cost around $7 million.

The dude in the picture being in a suit isn‟t an accident; these machines were used mostly

for nuclear weapons research and by huge corporations. The only people who used them

tended to be very senior engineers, due to their scarcity – there were, after all, only 123 of

them. And you couldn‟t just go to Best Buy and buy a new one.

52

If the „40s and „50s were ancient history, the late „60s through the „70s was the Roman

Empire of computer science.

This was the era in which computers (see next slide) really became available to university

research, and a lot of decisions that impact everything we do in computer science today

were made.

UNIX and VMS both appeared in this era; as it turns out, knockoffs of these two

operating systems (Linux and Windows respectively) currently dominant computing.

And Dennis Ritchie developed C in 1973, and then Bjarne Strousoup developed C++ in

1983.

Note these dates – First real computer in 1945, first programming language in 1957, and

then C in 1973. That‟s 16 years that programming languages existed before C was made.

Most faculty at the University of Kentucky have more experience with programming

languages than that – and that‟s more experience than anyone on earth had at the time.

Only 28 years from the first computer to C as well – and we‟ve got faculty with more

experience than that, too.

Which, perhaps, explains why there are a few mistakes in the design…

53

DEC PDP-11. 1970.

$110,000 in current dollars. 170,000 sold. Down to refrigerator size from classroom size.

This was one of the first machines that really started showing up in universities

everywhere and lead to the boom in computer science in the „70s.

54

IBM PC.

$8,000 in current dollars as standardly equipped; 20 million or so sold. There are now

150 million or so computers sold each year. Changed everything – before the IBM PC,

everyone who used a computer was a programmer, trained user, or enthusiast. The “end

user” was a theoretical concept before the IBM PC.

55

Or, an alternate theory – C was, after all, a product of the ‟70s, and opening a Sears

catalog from that era…

56

Demonstrates pretty clearly that it was not a good decade for decision-making.

57

All of which kinda puts this into perspective…

58

So, anyway, back to C++.

Strings.

59

Just like you need to have #include <iostream> to use cout and endl, you need to have

#include <string> at the top of your program to use strings.

60

Here‟s an updated program that uses strings.

We assign them to string literals, and can send them to cout. They can be const, just like

scalars (simple numeric types).

Note that unlike scalars, strings do have a default value if constructed and uninitialized;

they are, explicitly, an empty string if uninitialized.

Note also that both methods used to output the string – sending the subparts over to

cout via insertion operators, or using + to concatenate the strings together – produce the

same output. There‟s not much of a reason to prefer one over the other in a vacuum.

61

Output of the previous program.

62

Adding an extra long – “again.length()” here is the way we get an integer with the length

of the string.

63

Output of the program.

64