CS 509 Class Notes

Lecture Notes for Advanced Programming II

Part of standard C/C++.
- Part of the standard preprocessor, actually.
- "Preprocessor" means "precompilation".
Include statement syntax is not C++ syntax.
#include"include-file-name"
#include<include-file-name>
< > and "" have different search paths.
- < > usually searches system directories; " " doesn't.
- This depends a lot on the compiler.
- Compiler command-line options can manipulate the search paths.
  - The -I options for g++ and CC.

Includes implement textual inclusion.
- The contents of the include file replaces the include statement.
- Not like packages in ada or java.
Textual inclusion can cause problems.
- Large source files.
- Circular includes.
- Duplicate code.

Learn and use the #ifndef idiom for include files.

#ifndef _includefile_h_
#define _includefile_h_

// Included material here.

#endif

Standard include files need standard names.
- May pre-standard extensions; .h, .hh, .H, .hxx
The standard eliminated the extension.
- C++ and C standard include files have no extensions - no .h
- Some compilers may still accept .h standard includes.
  - Don't use it; it's nonstandard.
It usually doesn't mater, but sometimes it does.
- <string> is not <string.h> is not <cstring>
Other include filenames can be arbitrary.
- Filenames can include local conventions; / vs. \.
- Watch out for portability.

The C++ and C standard includes define names inside the std namespace.
- Names should be prefixed with std::.
- using declarations make this less cumbersome.
- But it's useful documentation.
Compilers respect this to varying degrees.
- Don't rely on a compiler's particular treatment.
- Use std:: or explicitly eliminate it.
Try to avoid subverting namespaces in include files.
- Be especially careful of using namespace.

Stream IO include files.
- <iostream>, <iomanip>, <fstream>
STL include files.
- <vector>, <list>, <map>, <iterator>, <algorithm>, <utility>, <queue>, <stack>, <deque>, <set>, <bitset>, <functional>, <memory>
Exception include files.
- <exception>, <stdexcept>
String include files.
- <string>, <sstream>
Odds and ends.
- <locale>, <limits>, <typeinfo>

C defines a set of standard include files too.
- These are available for use in C++.
- From C++, they are part of the std namespace, sometimes.
  - It depends on the compiler.
  - Macros are not part of a namespace.
Access them using C++ include conventions.
- Drop the .h and prepend a 'c'.
- For example, given the C include assert.h, use
```
#include <cassert>
```
- Accessing the .h forms from C++ is nonstandard.
- c-prepended headers make the proper C++ extern declarations, .h headers do not.

Assert macros in <cassert>.
```
assert((0 <= i) and (i < N));
```
assert()'s a macro, no std::.
Character functions in <cctype>.
```
ch = std::toupper(ch);
```
Math functions in <cmath>.
```
double x = std::log(M_PI);
```
M_PI is a macro, log() is a function; std::M_PI doesn't compile.
System-dependent limits in <climits>.
```
std::cout << "Biggest possible int is << INT_MAX << "\n";
```
std::INT_MAX doesn't compile either.
Time utilities in <ctime>.

Any other include files are non-standard.
- strcasecmp(), strings.h, X Window System includes.
- Filename syntax is arbitrary.
- These are non-standard, potentially non-portable features.
"non-standard" is not bad - "unconventional" is bad
Don't include source (.cc) files, but the STL does.
Templates trip over this convention.

Include statements implement textual inclusion.
- Big code, infinte includes.
Become familiar with the standard C and C++ include files.
- Reduce work, improve portablility.
Standard includes have no extensions, c prefix.
- Non-standard includes have whatever.
Learn and follow the include conventions.
- Including source, subverting namespaces.
- Learn the local conventions too.

This page last modified on 10 September 2002.