c++ 学习笔记

  • 1. Never Return a Pointer to a Local Object
  • 2. Function Declarations Go in Header Files

It may be temptingand would be legalto put a function declaration directly in each source file that uses the function. The problem with this approach is that it is tedious and error-prone. By putting function declarations into header files, we can ensure that all the declarations for a given function agree. If the interface to the function changes, only one declaration must be changed.

  • 3. Constraints on Specifying Default Arguments

Specify default argument(s) in either the function definition or declaration. However, a parameter can have its default argument specified only once in a file. Default arguments ordinarily should be specified with the declaration for the function and placed in an appropriate header

  • 4. Unlike other function definitions, inlines should be defined in header files.
  • 5. Functions cannot be overloaded based only on differences in the return type.
  • 6. It is a bad idea to declare a function locally. Function declarations should go in header files.

If we declare a function locally, that function hides rather than overloads the same function declared in an outer scope. As a consequence, declarations for every version of an overloaded function must appear in the same scope.

void print(const string &);
void print(double);   // overloads the print function
void fooBar(int ival)
  void print(int);   // new scope: hides previous instances of print
  print("Value: ");  // error: print(const string &) is hidden
  print(ival); // ok: print(int) is visible
  print(3.14); // ok: calls print(int); print(double) is hidden

  • 7. No Copy or Assign for IO Objects
  • cannot have a vector (or other container) that holds stream objects.
  • cannot have a parameter or return type that is one of the stream types. If we need to pass or return an IO object, it must be passed or returned as a pointer or reference:
  • 8. IO => Buffers Are Not Flushed if the Program Crashes

Flushing the Output Buffer

cout << "hi!" << flush;      // flushes the buffer; adds no data
cout << "hi!" << ends;       // inserts a null, then flushes the buffer
cout << "hi!" << endl;       // inserts a newline, then flushes the buffer
  • 9. When we copy one container into another, the types must match exactly: The container type and element type must be the same.
  • 10. Containers of Containers
vector< vector<string> > lines; // ok: space required between close >
vector< vector<string>> lines; // error: >> treated as shift operator

  • 11. >, >=, <, <= Supported only for vector and deque‘s iterator.

The reason that only vector and deque support the relational operators is that only vector and deque offer fast, random access to their elements. These containers are guaranteed to let us efficiently jump directly to an element given its position in the container. Because these containers support random access by position, it is possible for their iterators to efficiently implement the arithmetic and relational operations.

  • 12. Container Elements Are Copies

When we add an element to a container, we do so by copying the element value into the container. Similarly, when we initialize a container by providing a range of elements, the new container contains copies of the original range of elements. There is no relationship between the element in the container and the value from which it was copied. Subsequent changes to the element in the container have no effect on the value that was copied, and vice versa.

  • 13. we can think of a constructor as executing in two phases: (1) the initialization phase and (2) a general computation phase
         Sales_item::Sales_item(const string &book)
             isbn = book;
             units_sold = 0;
             revenue = 0.0;

    This constructor assigns, but does not explicitly initialize, the members of class Sales_item. Regardless of the lack of an explicit initializer, the isbn member is initialized before the constructor is executed. This constructor implicitly uses the default string constructor to initialize isbn. When the body of the constructor is executed, the isbn member already has a value. That value is overwritten by the assignment inside the constructor body.

    • 14. 不能在类声明中初始化const数据成员。以下用法是错误的,因为类的对象未被创建时,编译器不知道SIZE的值是什么。

    class A


        const int SIZE = 100;     // 错误,企图在类声明中初始化const数据成员

        int array[SIZE];              // 错误,未知的SIZE



    class A


        A(int size);      // 构造函数

        const int SIZE ;


    A::A(int size) : SIZE(size)    // 构造函数的初始化表




    A  a(100); // 对象 a 的SIZE值为100

    A  b(200); // 对象 b 的SIZE值为200


    class A


        enum { SIZE1 = 100, SIZE2 = 200}; // 枚举常量

        int array1[SIZE1]; 
        int array2[SIZE2];



    One thought on “c++ 学习笔记”

    Comments are closed.