// Comment to end of line
/* Multi-line comment */
#include <stdio.h> // Insert standard header file
#include "myfile.h" // Insert file in current directory
#define X some text // Replace X with some text
#define F(a,b) a+b // Replace F(1,2) with 1+2
#define X \
some text // Line continuation
#undef X // Remove definition
#if defined(X) // Condional compilation (#ifdef X)
#else // Optional (#ifndef X or #if !defined(X))
#endif // Required after #if, #ifdef
255, 0377, 0xff // Integers (decimal, octal, hex) 2147483647L, 0x7fffffffl // Long (32-bit) integers 123.0, 1.23e2 // double (real) numbers 'a', '\141', '\x61' // Character (literal, octal, hex) '\n', '\\', '\'', '\"' // Newline, backslash, single quote, double quote "string\n" // Array of characters ending with newline and \0 "hello" "world" // Concatenated strings true, false // bool constants 1 and 0
int x; // Declare x to be an integer (value undefined)
int x=255; // Declare and initialize x to 255
short s; long l; // Usually 16 or 32 bit integer (int may be either)
char c='a'; // Usually 8 bit character
unsigned char u=255; signed char s=-1; // char might be either
unsigned long x=0xffffffffL; // short, int, long are signed
float f; double d; // Single or double precision real (never unsigned)
bool b=true; // true or false, may also use int (1 or 0)
int a, b, c; // Multiple declarations
int a[10]; // Array of 10 ints (a[0] through a[9])
int a[]={0,1,2}; // Initialized array (or a[3]={0,1,2}; )
int a[2][3]={{1,2,3},{4,5,6}}; // Array of array of ints
char s[]="hello"; // String (6 elements including '\0')
int* p; // p is a pointer to (address of) int
char* s="hello"; // s points to unnamed array containing "hello"
void* p=NULL; // Address of untyped memory (NULL is 0)
int& r=x; // r is a reference to (alias of) int x
enum weekend {SAT,SUN}; // weekend is a type with values SAT and SUN
enum weekend day; // day is a variable of type weekend
enum weekend {SAT=0,SUN=1}; // Explicit representation as int
enum {SAT,SUN} day; // Anonymous enum
typedef String char*; // String s; means char* s;
const int c=3; // Constants must be initialized, cannot assign to
const int* p=a; // Contents of p (elements of a) are constant
int* const p=a; // p (but not contents) are constant
const int* const p=a; // Both p and its contents are constant
const int& cr=x; // cr cannot be assigned to change x
int x; // Auto (memory exists only while in scope) static int x; // Global lifetime even if local scope extern int x; // Information only, declared elsewhere
x=y; // Every expression is a statement
int x; // Declarations are statements
; // Empty statement
{ // A block is a single statement
int x; // Scope of x is from declaration to end of block
a; // In C, declarations must precede statements
}
if (x) a; // If x is true (not 0), evaluate a
else if (y) b; // If not x and y (optional, may be repeated)
else c; // If not x and not y (optional)
while (x) a; // Repeat 0 or more times while x is true
for (x; y; z) a; // Equivalent to: x; while(y) {a; z;}
do a; while (x); // Equivalent to: a; while(x) a;
switch (x) { // x must be int
case X1: a; // If x == X1 (must be a const), jump here
case X2: b; // Else if x == X2, jump here
default: c; // Else jump here (optional)
}
break; // Jump out of while, do, or for loop, or switch continue; // Jump to bottom of while, do, or for loop return x; // Return x from function to caller
try { a; }
catch (T t) { b; } // If a throws a T, then jump here
catch (...) { c; } // If a throws something else, jump here
int f(int x, int); // f is a function taking 2 ints and returning int
void f(); // f is a procedure taking no arguments
void f(int a=0); // f() is equivalent to f(0)
f(); // Default return type is int
inline f(); // Optimize for speed
f() { statements; } // Function definition (must be global)
T operator+(T x, T y); // a+b (if type T) calls operator+(a, b)
T operator-(T x); // -a calls function operator-(a)
T operator++(int); // postfix ++ or -- (parameter ignored)
extern "C" {void f();} // f() was compiled in C
Function parameters and return values may be of any type. A function must either be declared or defined before it is used. It may be declared first and defined later. Every program consists of a set of a set of global variable declarations and a set of function definitions (possibly in separate files), one of which must be:
int main() { statements... } or
int main(int argc, char* argv[]) { statements... }
argv is an array of argc strings from the command line. By convention, main returns status 0 if successful, 1 or higher for errors.
Functions with different parameters may have the same name (overloading). Operators except :: . .* ?: may be overloaded. Precedence order is not affected. New operators may not be created.
T::X // Name X defined in class T N::X // Name X defined in namespace N ::X // Global name X t.x // Member x of struct or class t p->x // Member x of struct or class pointed to by p a[i] // i'th element of array a f(x,y) // Call to function f with arguments x and y T(x,y) // Object of class T initialized with x and y x++ // Add 1 to x, evaluates to original x (postfix) x-- // Subtract 1 from x, evaluates to original x typeid(x) // Type of x typeid(T) // Equals typeid(x) if x is a T dynamic_cast<T>(x) // Converts x to a T, checked at run time static_cast<T>(x) // Converts x to a T, not checked reinterpret_cast<T>(x) // Interpret bits of x as a T const_cast<T>(x) // Converts x to same type T but not const sizeof x // Number of bytes used to represent object x sizeof(T) // Number of bytes to represent type T ++x // Add 1 to x, evaluates to new value (prefix) --x // Subtract 1 from x, evaluates to new value ~x // Bitwise complement of x !x // true if x is 0, else false (1 or 0 in C) -x // Unary minus +x // Unary plus (default) &x // Address of x *p // Contents of address p (*&x equals x) new T // Address of newly allocated T object new T(x, y) // Address of a T initialized with x, y new T[x] // Address of allocated n-element array of T delete p // Destroy and free object at address p delete[] p // Destroy and free array of objects at p (T) x // Convert x to T (obsolete, use .._cast<T>(x)) x * y // Multiply x / y // Divide (integers round toward 0) x % y // Modulo (result has sign of x) x + y // Add, or &x[y] x - y // Subtract, or number of elements from *x to *y x << y // x shifted y bits to left (x * pow(2, y)) x >> y // x shifted y bits to right (x / pow(2, y)) x < y // Less than x <= y // Less than or equal to x > y // Greater than x >= y // Greater than or equal to x == y // Equals x != y // Not equals x & y // Bitwise and (3 & 6 is 2) x ^ y // Bitwise exclusive or (3 ^ 6 is 5) x | y // Bitwise or (3 | 6 is 7) x && y // x and then y (evaluates y only if x (not 0)) x || y // x or else y (evaluates y only if x is false (0)) x = y // Assign y to x, returns new value of x x += y // x = x + y, also -= *= /= <<= >>= &= |= ^= x ? y : z // y if x is true (nonzero), else z throw x // Throw exception, aborts if not caught x , y // evaluates x and y, returns y (seldom used)
class T { // A new type
private: // Section accessible only to T's member functions
protected: // Also accessable to classes derived from T
public: // Accessable to all
int x; // Member data
void f(); // Member function
void g() {return;} // Inline member function
void h() const; // Does not modify any data members
int operator+(int y); // t+y means t.operator+(y)
int operator-(); // -t means t.operator-()
T(): x(1) {} // Constructor with initialization list
T(const T& t): x(t.x) {} // Copy constructor
T& operator=(const T& t) {x=t.x; return *this; } // Assignment operator
~T(); // Destructor (automatic cleanup routine)
explicit T(int a); // Allow t=T(3) but not t=3
operator int() const {return x;} // Allows int(t)
friend void i(); // Global function i() has private access
friend class U; // Members of class U have private access
static int y; // Data shared by all T objects
static void l(); // Shared code. May access y but not x
class Z {}; // Nested class T::Z
typedef int V; // T::V means int
};
void T::f() { // Code for member function f of class T
this->x = x;} // this is address of self (means x=x;)
int T::y = 2; // Initialization of static member (required)
T::l(); // Call to static member
struct T { // Equivalent to: class T { public:
virtual void f(); // May be overridden at run time by derived class
virtual void g()=0; }; // Must be overridden (pure virtual)
class U: public T {}; // Derived class U inherits all members of base T
class V: private T {}; // Inherited members of T become private
class W: public T, public U {}; // Multiple inheritance
class X: public virtual T {}; // Classes derived from X have base T directly
All classes have a default copy constructor, assignment operator, and destructor, which perform the corresponding operations on each data member and each base class as shown above. There is also a default no-argument constructor (required to create arrays) if the class has no constructors. Constructors, assignment, and destructors do not inherit.
template <class T> T f(T t); // Overload f for all types
template <class T> class X { // Class with type parameter T
X(T t); }; // A constructor
template <class T> X<T>::X(T t) {} // Definition of constructor
X<int> x(3); // An object of type "X of int"
template <class T, class U=T, int n=0> // Template with default parameters
namespace N {class T {};} // Hide name T
N::T t; // Use name T in namespace N
using namespace N; // Make T visible without N::
STDIO.H, CSTDIO (Input/output)
FILE* f=fopen("filename", "r"); // Open for reading, NULL (0) if error
// Mode may also be "w" (write) "a" append, "a+" update, "rb" binary
fclose(f); // Close file f
fprintf(f, "x=%d", 3); // Print "x=3" Other conversions:
"%5d %u %-8ld" // int width 5, unsigned int, long left just.
"%o %x %X %lx" // octal, hex, HEX, long hex
"%f %5.1f" // float or double: 123.000000, 123.0
"%e %g" // 1.23e2, use either f or g
"%c %s" // char, char*
"%%" // %
sprintf(s, "x=%d", 3); // Print to array of char s
printf("x=%d”, 3); // Print to stdout (screen unless redirected)
fprintf(stderr, ... // Print to standard error (not redirected)
getc(f); // Read one char (as an int) or EOF from f
ungetc(c, f); // Put back one c to f
getchar(); // getc(stdin);
putc(c, f) // fprintf(f, "%c", c);
putchar(c); // putc(c, stdout);
fgets(s, n, f); // Read line into char s[n] from f. NULL if EOF
gets(s) // fgets(s, INT_MAX, f); no bounds check
fread(s, n, 1, f); // Read n bytes from f to s, return number read
fwrite(s, n, 1, f); // Write n bytes of s to f, return number written
fflush(f); // Force buffered writes to f
fseek(f, n, SEEK_SET); // Position binary file f at n
ftell(f); // Position in f, -1L if error
rewind(f); // fseek(f, 0L, SEEK_SET); clearerr(f);
feof(f); // Is f at end of file?
ferror(f); // Error in f?
perror(s); // Print char* s and error message
clearerr(f); // Clear error code for f
remove("filename"); // Delete file, return 0 if OK
rename("old", "new"); // Rename file, return 0 if OK
f = tmpfile(); // Create temporary file in mode "wb+"
tmpnam(s); // Put a unique file name in char s[L_tmpnam]
STDLIB.H, CSTDLIB (Misc. functions)
atof(s); atol(s); atoi(s);// Convert char* s to float, long, int
rand(), srand(seed); // Random int 0 to RAND_MAX, reset rand()
void* p = malloc(n); // Allocate n bytes. Obsolete: use new
free(p); // Free memory. Obsolete: use delete
exit(n); // Kill program, return status n
system(s); // Execute OS command s (system dependent)
getenv("PATH"); // Environment variable or 0 (system dependent)
abs(n); labs(ln); // Absolute value as int, long
STRING.H, CSTRING (Character array handling functions)
Strings are type char[] with a '\0' in the last element used.strcpy(dst, src); // Copy string. Not bounds checked strcat(dst, src); // Concatenate to dst. Not bounds checked strcmp(s1, s2); // Compare, <0 if s1<s2, 0 if s1==s2, >0 if s1>s2 strncpy(dst, src, n); // Copy up to n chars, also strncat(), strncmp() strlen(s); // Length of s not counting \0 strchr(s,c); strrchr(s,c);// Address of first/last char c in s or 0 strstr(s, sub); // Address of first substring in s or 0 // mem... functions are for any pointer types (void*), length n bytes memmove(dst, src, n); // Copy n bytes from src to dst memcmp(s1, s2, n); // Compare n bytes as in strcmp memchr(s, c, n); // Find first byte c in s, return address or 0 memset(s, c, n); // Set n bytes of s to c
CTYPE.H, CCTYPE (Character types)
isalnum(c); // Is c a letter or digit? isalpha(c); isdigit(c); // Is c a letter? Digit? islower(c); isupper(c); // Is c lower case? Upper case? tolower(c); toupper(c); // Convert c to lower/upper case
MATH.H, CMATH (Floating point math)
sin(x); cos(x); tan(x); // Trig functions, x (double) is in radians asin(x); acos(x); atan(x);// Inverses atan2(y, x); // atan(y/x) sinh(x); cosh(x); tanh(x);// Hyperbolic exp(x); log(x); log10(x); // e to the x, log base e, log base 10 pow(x, y); sqrt(x); // x to the y, square root ceil(x); floor(x); // Round up or down (as a double) fabs(x); fmod(x, y); // Absolute value, x mod y
TIME.H, CTIME (Clock)
clock()/CLOCKS_PER_SEC; // Time in seconds since program started time_t t=time(0); // Absolute time in seconds or -1 if unknown tm* p=gmtime(&t); // 0 if UCT unavailable, else p->tm_X where X is: sec, min, hour, mday, mon (0-11), year (-1900), wday, yday, isdst asctime(p); // "Day Mon dd hh:mm:ss yyyy\n" asctime(localtime(&t)); // Same format, local time
ASSERT.H, CASSERT (Debugging aid)
assert(e); // If e is false, print message and abort #define NDEBUG // (before #include <assert.h>), turn off assert
NEW.H, NEW (Out of memory handler)
set_new_handler(handler); // Change behavior when out of memory
void handler(void) {throw bad_alloc();} // Default
IOSTREAM.H, IOSTREAM (Replaces stdio.h)
cin >> x >> y; // Read words x and y (any type) from stdin
cout << "x=" << 3 << endl; // Write line to stdout
cerr << x << y << flush; // Write to stderr and flush
c = cin.get(); // c = getchar();
cin.get(c); // Read char
cin.getline(s, n, '\n'); // Read line into char s[n] to '\n' (default)
if (cin) // Good state (not EOF)?
// To read/write any type T:
istream& operator>>(istream& i, T& x) {i >> ...; x=...; return i;}
ostream& operator<<(ostream& o, const T& x) {return o << ...;}
FSTREAM.H, FSTREAM (File I/O works like cin, cout as above)
ifstream f1("filename"); // Open text file for reading
if (f1) // Test if open and input available
f1 >> x; // Read object from file
f1.get(s); // Read char or line
f1.getline(s, n); // Read line into string s[n]
ofstream f2("filename"); // Open file for writing
if (f2) f2 << x; // Write to file
IOMANIP.H, IOMANIP (Output formatting)
cout << setw(6) << setprecision(2) << setfill('0') << 3.1; // print "003.10"
STRING (Variable sized character array)
string s1, s2="hello"; // Create strings s1.size(), s2.size(); // Number of characters: 0, 5 s1 += s2 + ' ' + "world"; // Concatenation s1 == "hello world" // Comparison, also <, >, !=, etc. s1[0]; // 'h' s1.substr(m, n); // Substring of size n starting at s1[m] s1.c_str(); // Convert to const char* getline(cin, s); // Read line ending in '\n'
VECTOR (Variable sized array/stack with built in memory allocation)
vector<int> a(10); // a[0]..a[9] are int (default size is 0) a.size(); // Number of elements (10) a.push_back(3); // Increase size to 11, a[10]=3 a.back()=4; // a[10]=4; a.pop_back(); // Decrease size by 1 a.front(); // a[0]; a[20]=1; // Crash: not bounds checked a.at(20)=1; // Like a[20] but throws out_of_range() for (vector<int>::iterator p=a.begin(); p!=a.end(); ++p) *p=0; // Set all elements of a to 0 vector<int> b(a.begin(), a.end()); // b is copy of a vector<T> c(n, x); // c[0]..c[n-1] init to x T d[10]; vector<T> e(d, d+10); // e is initialized from d
DEQUE (array/stack/queue)
deque<T> is like vector<T>, but also supports:a.push_front(x); // Puts x at a[0], shifts elements toward back a.pop_front(); // Removes a[0], shifts toward front
UTILITY (Pair)
pair<string, int> a("hello", 3); // A 2-element struct
a.first; // "hello"
a.second; // 3
MAP (associative array)
map<string, int> a; // Map from string to int a["hello"]=3; // Add or replace element a["hello"] for (map<string, int>::iterator p=a.begin(); p!=a.end(); ++p) cout << (*p).first << (*p).second; // Prints hello, 3 a.size(); // 1
ALGORITHM (A collection of 60 algorithms on sequences with iterators)
min(x, y); max(x, y); // Smaller/larger of x, y (any type defining <) swap(x, y); // Exchange values of variables x and y sort(a, a+n); // Sort array a[0]..a[n-1] by < sort(a.begin(), a.end()); // Sort vector or deque