Please enable JavaScript.

Coggle requires JavaScript to display documents.

Ch1 - Getting Started - Coggle Diagram

- - - - The int type is a built-in type, which means that it is one of the types the language defines.
      - the function body, is a block of state- ments starting with an open curly brace and ending with a close curly
        
        return, which is a statement that terminates a function. As is the case here, a return can also send a value back to the function’s caller. When a return statement includes a value, the value returned must have a type that is compatible with the return type of the function.
        
        Semicolons mark the end of most statements in C++.
    - - The main function is required to have a return type of int
        
        On most systems, the value returned from main is a status indicator.
        
        A return value of 0 indicates success.
        
        A nonzero return has a meaning that is defined by the system. Ordinarily a nonzero return indicates what kind of error occurred.
  - - - most compilers expect pro- gram source code to be stored in one or more files
        
        Program files are normally referred to as a source files.
        
        On most systems, the name of a source file ends with a suffix, which is a period followed by one or more characters. The suffix tells the system that the file is a C++ program. Different compilers use different suffix conventions; the most common include .cc, .cxx, .cpp, .cp, and .C.
    - - $ CC prog1.cc
        
        where CC names the compiler and $ is the system prompt.
      - The compiler gen- erates an executable file.
      - To run an executable on UNIX, we use the full file name, including the file extension:
        
        $ a.out
        
        If we need to specify the file’s location, we’d use a “.” followed by a forward slash to indicate that our executable is in the current directory
        
        $ ./a.out
      - The value returned from main is accessed in a system-dependent manner.
        
        On UNIX systems, we obtain the status by writing
        
        Bash: $ echo $?
        
        Fish: $ echo $status
      - RUNNING THE GNU OR MICROSOFT COMPILERS
        
        By default, the command to run the GNU compiler is g++:
        
        $ g++ -o prog1 prog1.cc
        
        Here $ is the system prompt. The -o prog1 is an argument to the compiler and names the file in which to put the executable file.
        
        Depending on the release of the GNU compiler you are using, you may need to specify -std=c++0x to turn on C++ 11 support.
        
        Compilers usually include options to generate warnings about problematic con- structs. It is usually a good idea to use these options. Our preference is to use -Wall with the GNU compiler
- - - - A single-line comment starts with a double slash (//) and ends with a newline.
        
        A comment of this kind can contain any text, including additional double slashes
      - The other kind of comment uses two delimiters (/* and */)
        
        These com- ments can include anything that is not a */, including newlines
        
        A comment pair can be placed anywhere a tab, space, or newline is permitted.
        
        Comment pairs can span multiple lines of a program but are not required to do so.
- - - - repeatedly executes a section of code so long as a given con- dition is true.
      - has the form
        while (condition) statement
        
        condition and body of while statement
      - executes by (alternately) testing the condition and executing the associ- ated statement until the condition is false.
        
        A condition is an expression that yields a result that is either true or false.
        
        the less-than-or-equal operator (the <= operator)
        
        A block is a sequence of zero or more statements enclosed by curly braces. A block is a statement and may be used wherever a statement is required.
        
        the compound assignment operator (the += operator).
        
        It has essentially the same effect as writing an addition and an assignment
        
        the prefix increment operator (the ++ operator)
  - - - The header controls how often the body is executed. The header itself consists of three parts: an init statement, a condition, and an expression.
        
        The variable created in init-statement exists only inside the for; it is not possible to use it after this loop terminates. The init-statement is executed only once, on entry to the for.
        
        The condition is tested each time through the loop.
        
        The expression is executed after the for body.
- - - - Most of the examples in this book use the iostream library.
        
        Fundamental to the iostream library are two types named istream and ostream, which repre- sent input and output streams, respectively.
        
        A stream is a sequence of characters read from or written to an IO device. The term stream is intended to suggest that the characters are generated, or consumed, sequentially over time.
    - - The library defines four IO objects.
        
        To handle input, we use an object of type istream named cin. This object is also referred to as the standard input.
        
        For output, we use an ostream object named cout. This object is also known as the standard output.
        The library also defines two other ostream objects, named cerr and clog. We typically use
        
        cerr, referred to as the standard error, for warning and error messages and
        
        clog for general information about the execution of the program.
        
        Ordinarily, the system associates each of these objects with the window in which the program is executed. So, when we read from cin, data are read from the window in which the program is executing, and when we write to cout, cerr, or clog, the output is written to the same window.
    - - #include <iostream> tells the compiler that we want to use the iostream library.
      - The name inside angle brackets refers to a header.
        
        In general, #include directives must appear outside any function.
        
        Typically, we put all the #include directives for a program at the beginning of the source file.
    - - The first statement in the body of main executes an expression.
      - In C++ an expression yields a result and is composed of one or more operands and (usually) an operator.
      - The expressions in this statement use the output operator (the << operator) to print a message on the standard output
        
        The << operator
        
        takes two operands
        
        The left-hand operand must be an ostream object;
        
        the right-hand operand is a value to print. The operator writes the given value on the given ostream.
        
        The result of the output operator is its left-hand operand. That is, the result is the ostream on which we wrote the given value.
      - The first output operator prints a message to the user. That message is a string literal, which is a sequence of characters enclosed in double quotation marks.
      - The second operator prints endl, which is a special value called a manipulator.
        
        Writing endl has the effect of ending the current line and flushing the buffer associated with that device.
        
        Flushing the buffer ensures that all the output the program has generated so far is actually written to the output stream, rather than sitting in memory waiting to be written.
    - - The prefix std:: indicates that the names cout and endl are defined inside the namespace named std.
        
        Namespaces allow us to avoid inadvertent collisions between the names we define and uses of those same names inside a library.
        
        Writing std::cout uses the scope operator (the :: operator) to say that we want to use the name cout that is defined in the namespace std
    - - We start by defining two variables named v1 and v2. We also initialize them to 0
        
        When we initialize a variable, we give it the indicated value at the same time as the variable is created.
        
        The input operator (the >> operator) behaves analogously to the output operator. Like the output operator, the input operator returns its left-hand operand as its result.
    - - The library defines versions of the input and output operators that handle operands of each of these differing types.