C++ programming intro

CS 342: Intro to C++ Programming

A Simple C++ Program
#include <iostream>
using namespace std;

int main() {
cout << “hello, world!” << endl;
return 0;
}

Copyright © 2004 Dept. of Computer Science and Engineering, Washington University


#include <iostream>
• #include tells the precompiler to include a file
• Usually, we include header files
– Contain declarations of structs, classes, functions
• Sometimes we include template definitions
– Varies from compiler to compiler
– Advanced topic we’ll cover later in the semester
• <iostream> is the C++ label for a standard
header file for input and output streams



• The using directive tells the compiler to include code
from libraries in a separate namespace
– Similar idea to Ada/Pascal “packages”
• C++ provides such a namespace for its standard
library
– cout, cin, cerr standard iostreams and much more
• Namespaces reduce collisions between symbols
– If another library defined cout we could say std::cout
• Can also apply using more selectively:
– E.g., just using std::cout


int main()
• Declares the main function of any C++ program
• Here, takes no parameters and returns an integer
– By convention in UNIX and many other platforms
• returning 0 means success
• returning non-zero indicates failure (may return error codes)
• Who calls main?
– The runtime environment (often from a function called
crt0)
• What about the stuff in braces?
– It’s the body of function main, its definition



cout<<“hello, world!”<<endl;
• Uses the standard output iostream, named cout
– For standard input, use cin
– For standard error, use cerr
• << is an operator for inserting into the stream
– A member “function” of the ostream class
– Returns a reference to stream on which its called
– Can be applied repeatedly to references left-to-right
• “hello, world!” is a C-style string
– A 14-postion character array terminated by ‘0’
• endl is an iostream manipulator
– Ends the line, by inserting end-of-line character(s)
– Also flushes the stream


A Slightly Bigger C++ Program
#include <iostream>
int main(int argc, char * argv[]) {
for (int i = 0; i < argc; ++i) {
cout << argv[i] << endl;
}
return 0;
}


int argc, char * argv[]
• A way to affect the program’s behavior
– Carry parameters with which program was called
– Passed as parameters to main from crt0
– Passed by value (we’ll discuss what that means)
• argc
– An integer with the number of parameters (>=1)
• argv
– An array of pointers to C-style character strings
– Its array-length is the value stored in argc
– The name of the program is kept in argv[0]

for(int i = 0; i < argc; ++i)
• Standard C++ for loop syntax
– Initialization statement done once at start of loop
– Test expression done before running each time
– Expression to increment after running each time
• int i = 0
– Declares integer i (scope is the loop itself)
– Initializes i to hold value 0
• i < argc
– Tests whether or not we’re still inside the array!
– Reading/writing memory we don’t own can crash the
program (if we’re really lucky!)
• ++i
– increments the array position

{cout << argv[i] << endl;}
• Body of the for loop
• You should use braces, even if there’s only
one line of code
– Avoids maintenance errors when
adding/modifying code
– Ensures semantics & indentation say same thing
• argv[i]
– An example of array indexing
– Specifies ith position from start of argv


C++ Types
• int, long, short, char (integer division)
• float, double (floating point division)
• signed (default) and unsigned types
• bool type
• enumerations
– enum primary_colors {red, blue, yellow};
• structs and classes
• pointers and references
• mutable (default) vs. const types



C++ Loops and Conditionals
• Loops
– for
– while
– do
• Conditionals
– if, else, else if
– ?: operator
– switch



C++ Operators
• Relational operators
== <= >= < > !=
• Assignment operators
= *= /= %= += -= &= |=
• Logical operators
! && ||
• Member selection operators
-> .
All of these return values
– Be careful of == and =


C++ Functions
• In C++, behavior need not be part of a class
– We’ll distinguish “plain old” functions vs. member functions
• Pass parameters by reference vs. by value
• Put declaration prototypes (no body) in header files
• Put definitions in source files (compilation units)
• Libraries often offer lots of helpful functions
– E.g., isalpha () from the <cctype> library


Parameter/Variable Declarations
• Read a function parameter or local variable
declaration right to left
int i; “i is an integer”
int & r; “r is a reference to an integer”
int * p; “p is a pointer to an integer”
int * & q; “q is a reference to a pointer to an integer”
int * const c; “c is a const pointer to an integer”
int const * d; “d is a pointer to a const integer”
• Read a function pointer declaration inside out
– More on this later


Pass By Reference
void foo() {
int i = 7; local variable i

baz (i); 7 ? 3

}

void baz(int & j) {
j = 3; 7 ? 3
} j is a reference to the
variable passed to baz

Pass By Value
void foo() {
int i = 7; 7 local variable i

baz (i);
}

void baz(int j) {
j = 3; local variable j
7 ? 3 (initialized with the value
} passed to baz)



C++ Classes and Structs
• Struct members are public
struct MyData { by default
MyData(int i) :m_x(i){} • Class members are
int m_x; private by default
};
• Both can have
– Constructors
– Destructors
class MyObject {
– Member variables
public:
– Member functions
MyObject(int y);
~MyObject(); • Common practice:
private: – use structs for data
int m_y; – use classes for objects with
methods
};
• Declarations usually go in
header files



C++ Classes and Structs
We also need an implementation
– Generally in the .cpp file

MyObject::MyObject(int y) :m_y(y) {
// It’s a good idea to assert your arguments
assert(y > 0);
}

MyObject::~MyObject() {
}



C++ string Class
#include <iostream> • <string> header file
#include <string>
• Various constructors
int main() { – Prata, pp. 780
string s; // empty • Assignment operator
s = “”; // empty • Overloaded operators
s = “hello”; += + < >= == []
s += “, ”;
s = s + “world!”; • The last one is really
cout << s << endl; useful: indexes string
return 0; if (s[0] == ‘h’) …
}



C++ Input/Output Stream Classes
#include <iostream> • <iostream> header file
using namespace std; – Use istream for input
– Use ostream for output
int main() {
• Overloaded operators
int i;
<< ostream insertion operator
// cout == std ostream >> istream extraction operator
cout << “how many?” • Other methods
<< endl; – ostream: write, put
// cin == std istream – istream: get, eof, good, clear
cin >> i; • Stream manipulators
– ostream: flush, endl, setwidth,
cout << “You said ” << i setprecision, hex, boolalpha
<< ‘.’ << endl; – Prata pp. 891-892
return 0;
}



C++ File I/O Stream Classes
#include <fstream> • <fstream> header file
using namespace std; – Use ifstream for input
int main() { – Use ofstream for output
ifstream ifs;
ifs.open(“in.txt”); • Other methods
ofstream ofs(“out.txt”); – open, is_open, close
if (ifs.is_open() && – getline
ofs.is_open()) { – seekg, seekp
int i; • File modes
ifs >> i; – in, out, ate, app, trunc, binary
ofs << i;
}
ifs.close();
ofs.close();
return 0;
}



C++ String Stream Classes
#include <iostream> • <sstream> header file
#include <fstream> – Use istringstream for input
#include <sstream> – Use ostringstream for output
• Useful for scanning input
int main() { – Get a line from file into string
ifstream ifs(“in.txt”); – Wrap string in a stream
if (ifs.is_open()) { – Pull words off the stream
string line1, word1; • Useful for formatting output
getline(ifs, line1); – Use string as format buffer
istringstream iss(line1); – Wrap string in a stream
iss >> word1; – Push formatted values into
cout << word1 << endl; stream
} – Output formatted string to file
return 0;
}


C++ programming intro

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (20)

En vedette

En vedette (7)

Similaire à C++ programming intro

Similaire à C++ programming intro (20)

C++ programming intro