Intro to C++ Lecture 2. Machine Language Ada Pascal Fortran COBOL Assembly Language Smalltalk Visual...
-
Upload
alexina-rose-stafford -
Category
Documents
-
view
227 -
download
0
Transcript of Intro to C++ Lecture 2. Machine Language Ada Pascal Fortran COBOL Assembly Language Smalltalk Visual...
Intro to C++Lecture 2
Machine Language
Ada
PascalFortranCOBOL
Assembly Language
Smalltalk
Visual BasicBASIC
JavaC and C++
Programming Languages…
Programming languages are artificial languages created to tell the computer what to do
They consist of vocabulary and a set of rules (grammar/syntax) to write programs
The software development life cycle (SDLC) is an organized method of software development
C++ Predecessors
Early procedural languages included FORTRAN: Formula Translation ALGOL: Algorithmic Language COBOL: Common Business Oriented Language BASIC: Beginners All-purpose Symbolic
Instruction Code Pascal C Smalltalk, Simula, etc. were the object-oriented
predecessors of C++
The Evolution
of Programming Languages
Third-Generation and Fourth-Generation (High-Level) Languages
First-Generation Languages Machine language:
Consists of binary numbers (0s and 1s)
Is the earliest programming language
Is the only language the computer understands without translation It is machine dependent;
each family of processors has its own machine language
Second-Generation Languages Assembly language:
Resembles machine language
Is a low-level language Uses brief abbreviations for
program instructions. Abbreviations are called
mnemonics A program is written in
source code (text file) and translated into machine language by an assembler
Third-Generation Languages
Procedural languages: Are high-level languages that tell the computer
what to do and how to do it Create programs at a high level of abstraction Are easier to read, write, and maintain than
machine and assembly languages Use a compiler or interpreter to translate code Fortran and COBOL are third-generation
languages
Compilers and Interpreters
An interpreter translates source code one line at a time and executes the instruction
A compiler is a program that changes source code to object code, all in one shot
Example of an interpreted language: BASIC; a compiled language: C
The Great Software Crisis of the 60’s Spaghetti Code and the Great Software Crisis:
goto statements resulted in programs that were difficult to follow
This made them difficult to modify, maintain, and even develop!
This problem led to the software crisis of the 1960s Programs were not ready on time Programs exceeded their budgets Programs contained too many errors Customers were not satisfied Management was also very frustrated!
Structured Programming to the rescue…
Structured programming languages: Were developed to improve software
development Include Algol and Pascal Are well-structured and organized Forbid the use of goto statements Use three fundamental control structures
Sequence, Selection, Repetition
Modular Programming Languages developed in the 70’s…
Modular programming languages: Were developed because of problems in
structured programming languages Are used to create programs that are divided
into separate modules Each module carries out a special function
Require specified input to produce specified output
Fourth-Generation Languages Fourth-generation languages are non-procedural, high-level
specification languages They do not force programmers to follow procedures to produce
results (they’re very close to English, sometimes) Types of fourth-generation languages include:
Report generators Languages for printing database reports (generate a program to generate
the report) Query languages
Languages for getting information out of databases (generate a program to process a query or generate a form)
Also include visually-oriented languages More ambitious 4GL environments attempt to automatically generate whole
systems from the outputs of CASE tools, specifications of screens and reports, and possibly also the specification of some additional processing logic, including data flow diagrams, entity relationship diagrams, entity life history diagrams
Fifth-generation languages These include artificial intelligence and neural networks oriented
languages
SKIP: Object-Oriented Programming
Object-oriented programming (OOP): Relies on component reusability
The ability to produce program modules that perform a specific task
Eliminates the distinction between programs and data
Uses objects that contain data and procedures
SKIP: Objects Objects are units of information that contain data as
well as methods that process and manipulate the data Classes of objects:
Hierarchy or category of objects Objects at the top of the category are broader in
scope than the subclass objects Objects near the bottom are narrower in scope
Inheritance refers to an object’s capacity to “pass on” its characteristics to its subclasses
Programming Language Classification Computer languages (not just programming languages!) can be classified into two
general categories: Imperative and Declarative Imperative languages include:
Generic/General Programming Languages They allow user-defined data types, data abstraction, polymorphism, etc.
Procedural Programming Languages Object-Oriented Programming Languages
Declarative languages include: Functional Programming Languages (e.g., Haskell, Scheme, etc.) Logical Programming Languages (e.g., Prolog) Even Markup Languages like HTML
They’re not programming languages because they don’t allow for the three fundamental control structures but they do declare what pages should look like, etc.
Procedural Programming (structured and modular): An important methodology for dealing with complexity is structured programming Structured Programming requires well-organized, structured code that uses the three
fundamental control structures (sequence, selection, repetition) Complex tasks need to be broken down into simpler subtasks this is modular
programming Procedural programming reduces complex problems to collections of simple,
interconnected modules – it combines structured and modular programming! It is up to the programmer to implement procedural programming
3GL Programming Languages
Most high-level programming languages can be categorized into one of three main categories: Procedural Languages (FORTRAN, BASIC,
COBOL, Pascal, etc.) Object-Oriented Languages (Smalltalk, Effiel,
etc.) Hybrid Languages allow both OO and
Procedural (such as C++)
3GL: Procedure-oriented (structured) languages Programmers concentrate on the procedures used in the program
Procedure: a logically consistent set of instructions which is used to produce one specific result
3GL: Object-oriented languages Items are represented using self-contained objects
Can be used to create programs for graphical windows environments
4GLs: fourth-generation languages Permit users to access and format information without the need
for writing any procedural code Use high-level English-like instructions to specify what to do, not
how to do it .
3GL vs. 4GL
Procedural Programming Basics
The purpose of most application programs is to process data to produce specific results
Basic procedural operations.
What Can a Procedural Program Do?
A linear, procedural program is structured to instruct a computer to: Read Input Calculate Store data Write Output Work in a sequential progression (Sequence) Compare and branch (Selection) Iterate or Loop (Repetition)
Advantages of Procedural Programming
Easier to test and debug Structured walkthroughs of the code
“goto-less” I.e., they’re well-structured and include the three
fundamental control structures Standard method for solving a problem A single program can be written by more than one
programmer By dividing the program up into modules
Programs can share routines (again, because of modularization)
What’s structured programming? A Structure is One or More Instructions
(Flowchart Symbols) Combined According to Rules E.g., only one point of entry and exit
Structured programming is a set of rules that prescribe good style habits for programmer. An organized, well structured code Easily sharable; easy to debug and test Requires shorter time to develop, test, and update
The key idea is that any numerical algorithm can be composed using the three fundamental control structures: Sequence, selection, and repetition
What Are the Rules for Writing a Structured Program?
3 basic control structures: Sequence Selection (decision) Repetition (looping or iteration)
Modularization
Modular Program: a program consisting of interrelated segments arranged in a logical and understandable form Easier to develop, correct, and modify than other
kinds of programs Module: a small segment which is designed to
perform a specific task A group of modules is used to construct a
modular program
Modular Programming Behind most software development over the last century Encourages subroutines Large programs are divided by functional parts into
subroutines or modules Go to instructions only permitted within subroutines Three objectives when creating routines:
Smaller, simpler routines Breakup complex routines into simple functions
Strong cohesion Routine does one function such as printing
• Instructions are closely related Loose coupling
Non-existent or weak connection between routines• One routine does not depend on other routines
SUBPROGRAM (function)
SUBPROGRAM1 . . .
SUBPROGRAM1 a meaningful collection of SEQUENCE, SELECTION, REPETITION (LOOP), or SUBPROGRAMS
Introduction to C++
Modules in C++ can be classes or functions Function: accepts an input and produces an
output by processing the input in some fashion A function’s processing is encapsulated and
hidden within the function
A Multiplying Function
Classes and Functions
Function: encapsulates a set of operations, while a class encapsulates data plus one or more sets of operations
Class: contains both data and functions used to manipulate the data
Identifier: a name given to an element of the language, such as a class or function
The Software Development Life Cycle (SDLC)
The SDLC was introduced in the 1970s to address problems in creating programs
It provides an organized plan for breaking down the task of program development into manageable parts
Five phases of the SDLC:
1. Defining the problem
2. Designing the program
3. Coding the program
4. Testing, debugging, and formalizing the program
5. Implementing and maintaining the program
Phase 1: Defining the Problem The first step in program development What do you want to solve? What is the objective and question? Get the requirements from the client (possibly other software
engineers) Systems analysts provide program specifications (specs) to the
programmers The specs define:
Input data Processing Output
• Including the appearance of the user interface Software engineers need clear specifications (as opposed to
requirements): Clear, specific statement of goal Expected output Expected input
Phase 2: Designing the Program Programmers create the program’s design
Top-down design focuses on the program’s main goal (main routine), then breaks the program into manageable components (subroutines/modules)
Control structures are used to see how each subroutine will do its job
Makes programming easier to develop, debug, and maintain
Developing an algorithm, which is a step-by-step description of how to arrive at a solution
Program design tools: Structure charts – show the top-down design Flow charts – show the logic of program Pseudocode – alternative to flow charts
Structured Design Structured programming implements structured design Control structures are logical constructs that specify
how the instructions in a program are to be executed Three fundamental types of control structures:
Sequence control structure – Instructions are executed in the order in which they appear
Selection control structures – The program branches to different instructions depending on whether a condition is met; IF…THEN…ELSE
Repetition control structure – The program repeats the same instructions over and over; DO-WHILE and DO-UNTIL
Structure Chart
Flowchart
Structure Chart and Flowchart
Phase 3: Coding the Program
Coding requires the translation of the algorithm into specific program instructions
An appropriate programming language is chosen, and the code is typed according to its syntax rules
Documentation is created for future use Best if the documentation is done in-line using a tool like
JavaDoc, Doxygen, etc. The variable names and definitions, a description of the
files needed, and the layout of the output are produced A user manual is developed to explain how the
program works
Phase 4: Testing and Debugging the Program
Testing and debugging eliminate all errors Syntax and logic errors are corrected Debugging is the process of eliminating errors
Phase 5: Implementing and Maintaining the Program
The program is: Tested by users Thoroughly documented Maintained and evaluated regularly
Algorithms
Algorithm: A step-by-step sequence of instructions that must terminate Pseudocode
Use of English-like phrases to describe an algorithm Formula
Use of mathematical equations to describe an algorithm
Flowchart Use of diagrams that employ symbols to describe an
algorithm
Program Design Process
AL-KHOWARIZMI
Grace M. HopperFirst “Bug”
Algorithm Design(underlying logic of program)
Program Composition
Debug & test(error free & reliable)
Documentation
Maintenance
75% of costs!
What’s an Algorithm?
A predetermined series of instructions for carrying out a task in a finite number of steps I.e., Baking A Cake!
Two commonly used tools to help document the program logic (the algorithm): Flowcharts and Pseudocode.
Generally, Flowcharts work well for small problems but Pseudocode is used for larger problems
How to make a plan …?
Do a hand calculation (brainstorming!)
Make a flowchart
Visio or dia
Write the Pseudocode
Flowchart: Symbolic Representation of Algorithms
Flowchart: A graphic representation of an algorithm often used in the design phase of programming to work out
the logical flow of a program Uses symbols to represent each logical step of the
algorithm. The order in which the steps are carried out is indicated by
connecting “flow lines” Use a few, basic flowchart symbols Follow UML (Unified Modeling Language)
Standard defined by OMG group: http://www.omg.org/technology/documents/formal/uml.htm
Basic Flowchart Symbols Some basic symbols:
Basic Control Structures a sequence is a series of statements that execute one after
another
selection (branch) is used to execute different statements depending on certain conditions
repetition (looping) is used to repeat statements while certain conditions are met.
a subprogram (module) is used to break the program into smaller units
SEQUENCE
Can contain any symbol except for the decision or loop symbol
Steps are executed in sequence with no instruction changing the order
Flow lines connect each instruction
SELECTION (branch)
REPETITION (loop)
Logical steps
Written in English and symbols, terms, etc.
Indenting for logical structures
begin some game display instructions pick a number between 1 and 100
repeat turn until number is guessed or seven turns are completed input guess from user respond to guess end repeat
end some game display end message
Looks like BASIC (Chris Clark)
Pseudocode
Pseudocode for three control constructs
What is Pseudocode? An alternative to flowcharting Represents logic in an English-like manner Rules
Avoid the use of words peculiar to a particular programming language
Indent lines to make the pseudocode easy to read and understand
Show key words (Move, Write, Read) in a different color, font, or capitalized
Punctuation is optional End every If with EndIf Begin every loop with a Loop instruction; End every loop with
EndLoop Main routine is to be shown first Terminate all routines with an End instruction (e.g., EndMain)
Write an algorithm in pseudocode that finds the average of two numbers
Example 1
StartAverageOfTwo0. Input: Two numbers1. Add the two numbers2. Divide the result by 23. Return the result by step 2
End
SKIP: Average of two
Write an algorithm to change a numeric grade to a pass/no pass grade.
Example 2
Pass/NoPassGradeInput: One number
1. if (the number is greater than or equal to 70)then 1.1 Set the grade to “pass”else 1.2 Set the grade to “nopass”End if
2. Return the gradeEnd
SKIP: Pass/No Pass Grade
Flowchart & Pseudocode
Start
Sum=0Count = 0
InputGrade
More grades?
Sum = Sum + GradeCount = Count + 1
Average = Sum/Count
Stop
No
Yes
FlowchartPseudocode
BEGIN Average Grade sum=0 count = 0 DO INPUT grade IF grade < 0 EXIT sum = sum + grade count = count +1 END DO IF count > 0 THEN average = sum/count ELSE average = 0 END IFEND Average Grade
Your first program in C++
hello.cpp compiler a.out
Writing a program in Linux involves three steps…
Details of a Typical C++ EnvironmentPhases of C++ Programs:
1. Edit
2. Preprocess
3. Compile
4. Link
5. Load & Execute Loader
PrimaryMemory
Program is created inthe editor and storedon disk.
Preprocessor programprocesses the code.
Loader puts programin memory.
CPU takes eachinstruction andexecutes it, possiblystoring new datavalues as the programexecutes.
CompilerCompiler createsobject code and storesit on disk.
Linker links the objectcode with the libraries,creates a.out andstores it on disk
Editor
Preprocessor
Linker
CPU
PrimaryMemory
.
.
.
.
.
.
.
.
.
.
.
.
Disk
Disk
Disk
Disk
Disk
Code (write) the program
Carefully enter the code
Remember most C++ statements end with a ;
Commands are in lower case
DEMO: 1. Edit
Start up an editor (emacs) to edit a file called hello.cpp Type the following into the file:
#include <iostream>
using namespace std;
int main(void){
cout << “Hello World” << endl;
return 0;
}
DEMO: 2. Compile
Compile your program g++ hello.cpp
This tells the computer to call the compiler to create the program
The compiler is a program that takes the code that you write and translates it into machine language
Machine code is made up of many simple instructions composed of 0’s and 1’s
DEMO: 3. Execute
You should now have a file called a.out inside your directory This file is called an executable a.out holds the binary version of your code
(the computer doesn’t understand words, just 0’s and 1’s)
To run the program type: ./a.out
What does the code mean?
#include <iostream> using namespace std; Allows us to use functions that other people
have written to facilitate input and output Processed by the pre-processor (it’s called a
pre-processor directive) Literally copies and pastes the libraries of
functions that others wrote This is what makes Java and MFC so powerful!
What does the code mean?
int main(void) Remember, every C++ program is made of one or
more functions A function is a piece of code that accomplishes one
specific task Every executable C++ program has one function
called main() This is where execution (the actual running) of the
program (i.e., the computer instructions) starts…
What does the code mean?
int main(void) When you type ./a.out to run the program you
are essentially telling the computer to call this main() functionCalling a function means to execute the code in
the function
What does the code mean?
int main(void) The int is the return type of the function.
In other words when it finishes what kind of result does it give back. A whole number? A character?
int means a whole number. We want to give this number back to tell us if the
program was sucessfully completed
What does the code mean?
int main(void) The void in the brackets is the parameter list
for this function The parameter list indicates what this function
needs to be given from the outset for it to work void indicates that we give nothing to this
function.
What does the code mean?
cout << “Hello World” << endl; This line tells the computer to print something to
the screen If you want to print something to the screen you
use the cout function The endl adds an “end line” and flushes the
buffer
What does the code mean?
return 0; This is the last line in our program It basically means that the program is now done return means to go back to where the
program was called from 0 is used to indicate that it was successfully
completed (a general convention)
What does the code mean?
Note also that the code of main() is contained within the { }
These {} group code together. In this case it tells us that all the code between them
are part of the main function
#include <iostream>using namespace std;int main(void){ cout << “Hello World” << endl; return 0;}
Some Important Terms A source program (.cpp file type) consists of the program statements
comprising a C++ or other programming language program. An object program (.obj file type) is the result of compiling a source
program. Header files (.h file type) contain constant, variable, and function
declarations needed by a program. An executable program is a program that can be run by a computer. Linking adds code from libraries to your file. Collects the object code
from all files in the workspace and puts them into one executable program.
A compiler is a program that translates a source program into an object program.
An interpreter is a program that translates individual source program statements, one at a time, into executable statements. Each statement is executed immediately after translation.
Compiling / Building
(.cpp file)source source codecode compiler
(.obj file)object codeobject code
(.h files)
linked to libraries
executable executable filefile
object code from other source files
Error, error… does not compute! Syntax Errors – Typing Errors
Errors in spelling and grammar (syntax). “Doag. Bites, Man”
You can use the compiler or interpreter to uncover syntax errors.
You must have a good working knowledge of error messages to discover the cause of the error.
Semantic Errors – Logic or Meaning Errors Errors that indicate the logic used when coding the program
failed to solve the problem. “Man bites dog.”
You do not get error messages with logic errors. Your only clue to the existence of logic errors is the
production of wrong solutions. Run-time Errors (Exceptions)
Code does something illegal when it is run (hence runtime) E.g., divide by zero
Syntax refers to the structure of a program and the rules about that structure
Procedural programming produced significant improvements in software quality and development time…
So…Why are Programmers Now Using Object-Oriented Programming?
Increasing dependence on information processing is creating a crisis
Volume of information is increasing faster than the ability to create software
Programmers cannot generate software to keep pace with the potential of new hardware
Some Programming Issues are Not Adequately Addressed by Procedural Programming
It is rarely possible to anticipate the design of a completed system before it’s actually implemented Systems are works in progress
Development of GUIs is very complicated in traditional procedure-oriented programming languages
Sharing data across routines is difficult and error-prone Focus of structured programming is on the modularity and procedures Data interactions are ignored Allowing modules to share all their data and interact freely creates subroutines that
are very dependent on each other--therefore, we don’t have independent routines
So, What’s the Answer to the Data Sharing Problem?
Modularize the data along with the procedures by giving each subroutine its own local data that it alone can read and write
INFORMATION HIDING
Information Hiding Allows the Programmer to Work with Modules or Procedures Developed by Others at an Abstract Level Abstraction Internal details are hidden from the user Data and procedures are not exposed to
procedures not needing to know them
Another Advantage of Object-Oriented Programming is Reusability
Building a house Electrical system Plumbing system Heating/air
conditioning system
Objects in Windows Buttons Menus Fields
How Procedural Programming Looks at a Problem
Procedures Data acted upon by the procedures are
maintained separately from the procedures Data assumes a secondary role!
Program
Procedure
Procedure Data
How Object-Oriented Programming Looks at a Problem?
Objects Data Methods Scope
Methods surround the data and protect data from other objects
Encapsulation and Information Hiding!
Met
hod Method
Method
Met
hod
Data
OBJECT
Objects Objects are things (nouns) Objects have attributes (properties)
Adjectives that describe an object Objects have methods (behaviors)
Verbs that specify what the object can do Events are used to trigger behaviors Objects interact with each other by passing
messages amongst themselves
Why Do We Still Write Procedural Programs?
Way of breaking a program into routines Object-oriented programming works at a
higher level of abstraction than procedural programming does
After objects have been identified, methods are designed using procedural techniques We are concentrating on methods or
procedures
Sample Cobol program
Common Business-Oriented Language (COBOL) COBOL:
The earliest (1959) high-level language
The most widely used business language
A proven way to do accounting, inventory, billing, and payroll
Requires programmers to explain what the program is doing at each step
Sample Fortran program
Formula Translator (Fortran) Fortran:
Began in the 1950s Is suited to scientific, mathematical, and engineering applications
Is used to solve complex equations
Features simplicity, economy, and ease of use
Sample Ada program
Ada Ada:
Named after Augusta Ada Byron
Incorporates modular programming
The required language for the U.S. Defense Department
Suitable for control of real-time systems (missiles)
Sample BASIC program
Beginner’s All-Purpose Symbolic Instruction Code (BASIC)
BASIC: An easy-to-use language available on personal
computers Widely taught in schools as a beginner’s programming
language Designed as an interpreted language
Visual Basic (VB)
Visual Basic: Is widely used in program development packagesUses event-driven programmingEnables the programmer to develop an application by using on-screen graphical user interfaces
Sample Visual Basic
Sample Pascal programPascal
Pascal: Is named after Blaise Pascal Encourages programmers to write well-structured programs Widely accepted as a teaching language Has been updated to reflect new approaches to
programming
Sample C program
C C:
Was developed by AT&T’s Bell Labs in the 1970s
Combines high-level programming language with assembly language
Programmers manipulate bits of data within a processing unit
Difficult to learn and programming is time consuming
Sample Smalltalk program
Smalltalk
Smalltalk: Developed in the 1970s by
Xerox Corp “100% pure” object-
oriented programming language
Not often chosen for software development
C++ C++:
Incorporates object-oriented features
Is widely used for professional program development
Sample C++ program
Java
Java: Developed by Sun Microsystems An object-oriented, high-level
programming language with a twist First true cross-platform
programming language Gained acceptance faster than any
other programming language A simplified version of C++
Java
Java, continued : Java is designed to run on any computer platform Java Virtual Machine enables cross-platform use Java applets or small programs are downloaded
to computers through networks Weaknesses include:
The security risk in downloading applets The speed in running the programs
Sample Java Program
Web-Based Languages Markup languages:
Hypertext markup language (HTML) sets the attributes of text and objects within a Web page
Extensible markup language (XML) is used for sharing data and objects in a Web environment
Scripting languages: VBScript is used to write short programs (scripts)
that are embedded in Web pages JavaScript is used to write scripts on Web pages
Visual Studio .NET: Used for the development of scripts and programs
that are accessible from the Web
The Programming Life Cycle
Define the problem
Make or buy software?
Design the program by making an algorithm
Code (write) the program
Document the program
Compile and execute the program
Syntax and run time errors
Test (debug) the program
Logic errors
Summary• A programming language is an artificial language
consisting of a vocabulary and a set of rules• Machine language is the lowest-level programming
language• Assembly language contains symbols for
programming instructions• Third-generation (high-level) languages require
programmers to specify the procedures to be followed• Object-oriented languages combine procedures and
data
Summary, continued• The SDLC’s six phases are:
• Defining the program• Designing the program• Coding the program• Testing, debugging, and formalizing the program• Implementing and maintaining the program
• Top-down programming makes programs easier to debug and maintain
• Debugging requires finding and correcting syntax errors and logic errors
Flowcharts for the three constructs
Alternative Control Structure Flowcharts
Sequence Selection Repetition (Looping)
Pseudocode! What is pseudocode?
Pseudocode is basically short, English phrases used to explain specific tasks within a program's algorithm. Pseudocode should not include keywords in any specific computer languages. Indentation can be used to show the logic in pseudocode as well.
Why is pseudocode necessary? Writing pseudocode WILL save you time later during the construction & testing phase of a program's
development let’s you “think out” the program before you code it. How do I write pseudocode?
Consists mainly of executable statements
Original Program Specification: Write a program that obtains two integer numbers from the user. It will print out the sum of those numbers.
Variables required (names and types): int1: (integer) to store first integerint2: (integer) to store the second integersum: (integer) to store the sum of the numbers
Pseudocode: Prompt the user to enter the first integer int1Prompt the user to enter a second integer int2Compute the sum of the two user inputs sum = int1 + int2Display an output prompt that explains the answerDisplay the result
If you can’t write it in pseudocode, you won’t be able to write it in C++!