Professional C__ - Marc Gregoire [3]
#ifndef MYHEADER_H
#define MYHEADER_H
// ... the contents of this header file
#endif
If your compiler supports the #pragma once directive, this can be rewritten as follows:
#pragma once
// ... the contents of this header file
Chapter 9 discusses this in more details.
The main() Function
main() is, of course, where the program starts. An int is returned from main(), indicating the result status of the program. The main() function either takes no parameters, or takes two parameters as follows:
int main(int argc, char* argv[])
argc gives the number of arguments passed to the program, and argv contains those arguments. Note that the first argument is always the name of the program itself.
I/O Streams
If you’re new to C++ and coming from a C background, you’re probably wondering what std::cout is and what has been done with trusty old printf(). While printf() can still be used in C++, a much better input/output facility is provided by the streams library.
I/O streams are covered in depth in Chapter 15, but the basics of output are very simple. Think of an output stream as a laundry chute for data. Anything you toss into it will be output appropriately. std::cout is the chute corresponding to the user console, or standard out. There are other chutes, including std::cerr, which outputs to the error console. The << operator tosses data down the chute. In the preceding example, a quoted string of text is sent to standard out. Output streams allow multiple data of varying types to be sent down the stream sequentially on a single line of code. The following code outputs text, followed by a number, followed by more text.
std::cout << "There are " << 219 << " ways I love you." << std::endl;
std::endl represents an end-of-line sequence. When the output stream encounters std::endl, it will output everything that has been sent down the chute so far and move to the next line. An alternate way of representing the end of a line is by using the \n character. The \n character is an escape character, which refers to a new-line character. Escape characters can be used within any quoted string of text. The following table shows the most common escape characters.
\n new line
\r carriage return
\t tab
\\ the backslash character
\" quotation mark
Streams can also be used to accept input from the user. The simplest way to do this is to use the >> operator with an input stream. The std::cin input stream accepts keyboard input from the user. User input can be tricky because you can never know what kind of data the user will enter. See Chapter 15 for a full explanation of how to use input streams.
Namespaces
Namespaces address the problem of naming conflicts between different pieces of code. For example, you might be writing some code that has a function called foo(). One day, you decide to start using a third-party library, which also has a foo() function. The compiler has no way of knowing which version of foo() you are referring to within your code. You can’t change the library’s function name, and it would be a big pain to change your own.
Namespaces come to the rescue in such scenarios because you can define the context in which names are defined. To place code in a namespace, enclose it within a namespace block:
namespace mycode {
void foo();
}
Code snippet from namespaces\namespaces.h
The implementation of a method or function can also be handled in a namespace:
#include #include "namespaces.h" namespace mycode { void foo() { std::cout << "foo() called in the mycode namespace" << std::endl; } } Code snippet from namespaces\namespaces.cpp By placing your version of foo() in the namespace “mycode,” it is isolated from the foo() function provided by the third-party library. To call the namespace-enabled version of foo(), prepend the namespace onto the function name by using :: also called the scope resolution operator as follows. mycode::foo(); // Calls the "foo" function in the "mycode" namespace Any code that falls within a “mycode” namespace block