C++ Primer 学习笔记

C++ Primer 学习笔记

Dec 26, 2013
Coding
C++

1. 后缀名 #

C++源程序文件后缀名在不同产品中是不同的。一般而言为.cpp，也有记作.cc、.cxx、.c++。

在Unix系统中，text.c 习惯上被当作C++源程序文件

C++头文件后缀名在不同产品也是不同的。一般而言为.h，也有记作.hxx、.hpp。

通常.hpp是既包含声明又包含实现的c++文件，常见于一些开源代码中

标准C++头文件，是没有后缀名，如 #include<vector>

2. include 预处理指示符 #

preprocessor include directive

  • <> : 表明文件是一个工程或者标准头文件，会首先在系统目录下查找
  • "" : 用户提供的头文件，会首先在工程中查找

3. 条件指示符 #ifndef #ifdef #

#ifdef 用来判断是否已经定义了某个宏，#ifndef 用来判断是否没有定义某个宏。配合使用的是 #else 和 #endif。它们统称为条件编译指令。

#ifndef SOME_STRING　     //如果没有定义SOME_STRING
#define SOME_STRING       //    则定义SOME_STRING
#else                     //如果已经定义了
  //some code             //    则做另一些事
#endif                    //宏结束

4. 编译器自动定义预处理名字 #

编译C++程序，编译器会自动定义预处理名字：__cplusplus

编译C程序，编译器会自动定义预处理名字：__STDC__

  • __LINE__: 记录文件已经被编译的行数
  • __FILE__: 正在编译的文件的名字
  • __TIME__: 当前被编译文件的编译时间 hh:mm:ss _ __DATE__: 当前被编译文件的编译日期 Oct 5 2011

img.png

5. assert #

assert() 是C语言标准库中提供的一个通用预处理器宏。如果括号内的条件为真，则继续往下执行，如果不为真，则报错。assert宏只在debug版本有效，在release版本中会被自动忽略。使用宏，需要包含相应头文件，c标准库中为

#include <assert.h>

在C++ 中为 #include <cassert> (这是通用的转化准则，去掉.h 前缀c)

#include <cassert>
using namespace std;//这句是必须的，不然，assert仍然不可用

6. 标准输出、标准错误、标准日志 #

标准输出cout、标准错误cerr、标准日志clog。三者都可以输出信息，具体区别如下
cout 写标准输出流 standard output stream 有缓冲区
cerr 写标准错误流 standard error stream 无缓冲
clog 写标准错误流 standard error stream 有缓冲

标准输出流和标准错误流其实没有什么功能上的区别，仅仅是两个可以分别被重定向的流而已。三者的主要区别在于有无缓冲区。有缓冲区，则会先把数据缓冲在缓冲区内，缓冲区满时一起输出；无缓冲区则直接输出。从字面可以知道，cout通常用来正常的输出数据，cerr用来输出一些错误信息，clog用来输出日志数据。但实际中，三者的输出设备都是标准显示器。如下面的代码，都会在显示器上显示。

cerr << "This is my error" << endl;
cout << "This is my output" << endl;
clog << "This is my log" << endl;

7. 动态内存 #

动态对象，也就是new出来的对象，没有名字，我们通过指针间接的对它进行操作。详细的内容参考C++/C#中堆栈、对象内存模型、深浅拷贝、Array.Clone方法.

8. 内联函数 inline #

将函数定义为内联函数有两种方法：对与全局函数，只要在该函数声明或定义时在前面加上关键词inline就可以了；对于类的成员函数，当函数的实现在类体内部时，该函数就被默认为inline函数，当函数的实现在类体外部时，只需像全局函数一样加上关键词inline就可以了。

最后一点要注意的是，即使你把一个函数声明或定义成了inline函数，也不能保证该函数一定能被编译器当作内联函数来处理，只能说是建议当作内联函数来处理，例如当你的函数体很大，编译器就基本不会把它当作内联函数来处理，这会因为频繁调用该函数而导致程序代码体积的极速膨胀，在内存较小的机器中，会影响指令高速缓冲装置的击中率。

内联是一种编译器请求（建议），而不是命令

class A{
private:
    int a;
public:
    void setA(int value) {a = value;}
    int get2A();
};

inline int A::get2A() {
    return 2 * a;
}

setA自动会被认为是inline函数

  • 宏定义：预处理器处理
  • inline：编译器处理

9. 引用与指针 #

可以简单的这么理解它们的区别

  • 指针是一个变量，保存了一个地址（p=0xFFFF0000）；
  • 引用是一个常量，内容是一个地址（const r = 0xFFFF0000）

具体的区别体现在

  • 指针指向一块内存，它的内容是所指内存的地址；引用是某块内存的别名。
  • 指针是一个实体，而引用仅是个别名；
  • 引用使用时无需解引用(*)，指针需要解引用；
  • 引用只能在定义时被初始化一次，之后不可变；指针可变；（可以通过变量、常量的区别来理解）
  • 引用不能为空，指针可以为空；
  • “sizeof 引用” 得到的是所指向的变量(对象)的大小，而 “sizeof 指针” 得到的是指针本身(所指向的变量或对象的地址)的大小；typeid(T) == typeid(T&) 恒为真，sizeof(T) == sizeof(T&) 恒为真，但是当引用作为成员时，其占用空间与指针相同（没找到标准的规定）。
  • 指针和引用的自增(++)运算意义不一样；

引用和指针的定义方法

int a = 6;
int &b = a;  // 定义引用
int *c = &a; // 定义指针

类型转换时的引用

double a = 3.14;
const int &b = a; // 如果写成 int &b = a; 则编译错误
a = 5;
cout << b << endl;

// 对于不可寻址的值，如文字常量，不同类型的值
// 编译器为了实现引用，必须生成一个临时对象
// 引用保存的实际是改对象的地址，但用户无法访问它
// 即上述代码实际转化成了下面的形式
//
// double a = 3.14
// int tmp = a;
// const int &b = tmp;

由上图可知：如果不将b定义成const，那么当b发生变化时，并不会影响a的值，那就不再是引用的的概念了。当定义成const，b是只读，b仍然相当保存了a的地址，还是引用。

10. 异常处理 # 

void fun() throw(int,string){…}

详细用法参考 C++异常处理实例

11. 命名空间Namespace #

命名空间是为了解决名称冲突问题，处在不同命名空间中的变量、方法、类等，即便名称相同，也不会冲突。

可以给命名空间定义别名，来方便使用。方法如下

namespace newName = oldName;

12. 常量 #

C++ 语言可以用const来定义常量，也可以用 #define 来定义常量。但是前者比后者有更多的优点：

  1. const常量有数据类型，而宏常量没有数据类型。编译器可以对前者进行类型安全检查。而对后者只进行字符替换，没有类型安全检查，并且在字符替换时可能会产生意料不到的错误（边际效应）。
  2. 有些集成化的调试工具可以对const常量进行调试，但是不能对宏常量进行调试。

【规则】在C++ 程序中只使用const常量而不使用宏常量，即const常量完全取代宏常量。

13. C++关键字 63个 # 

asm          auto     bool     break    case
catch        char     class    const    const_cast
continue     default  delete   do       double
dynamic_cast else     enum     explicit export
extern       false    float    for      friend
goto         if       inline   int      long
mutable    namespace  new      operator private
protected   public    register reinterpret_cast return
short       signed    sizeof   static   static_cast
struct      switch    template this     throw
true        try       typedef  typeid   typename
union       unsigned  using    virtual void
volatile    wchar_t   while

详见 c/c++标准及各编译器的支持情况

14. 变量初始化 #

对于int、double：

  • 全局变量，编译器赋初始值0。
  • 局部变量，需要手动赋初始值。（new出来的变量也是一样）

对于char：

  • 全局和局部都是赋0（ASCII码）

15. \0的理解 # 

const char* p = "Hello world";

最后一位是\0，所以下面这条语句

while(*p++) //先*p,后p++
  • 先 *p，取出其中的内容，进行while判断，再p++。循环结束时，p指向 \0 的下一位。
  • 当字符串结束时，会有一个\0，此时*p不为真，while条件即为false，退出

16. const 指针的理解 #

紧跟在const关键字后面的就是不能变动的。

用法一

const char* p = "Hello Everyone!";

表示 char* 是不能变动的，即p指针所指向的内存块的内容不能变，即 “Hello Everyone!” 不能变，但是str本身可以变，它可以指向另一块内存区，如

char* p1 = "Hello World"; //再定义一个字符串p1

p = p1;//把p1赋值给p,此时p指针指向了p1所指的内存区域 
//虽然这样，Hello Everyone!这块内存块就没有指针指向它了，成了垃圾。
//但语法上是正确的

//p[0] = 'a'; //错误，因为p指向的内存块的内容不能变

用法二

char* const p = “Hello Everyone!”;

表示str是不能变动的，即p指针所保存的地址不能变，只能一直指向某个固定的内存块，但是这个内存块本身的内容可以改。如

p[0] = '0';//正确，指向的内存块的内容可以变

char* str1 = "Hello World";

//p = p1;//错误，p保存的地址不能变，所以它不能再指向另一个内存块。

17. bool类型 #

  1. 为什么要使用内置bool类型，而不是自己通过typedef、enum等模拟出来的bool类型？

    • 程序可读性好！
    • 给编译器优化代码的机会。
    • 内置bool类型一般均为 1 个字节。有些CPU将bool类型优化成存储器的某个位

  2. C语言中的bool类型

C++内置对布尔类型的支持，其关健字是bool，C语言直到C99标准才增加了对布尔类型的支持，关健字为_Boo1，因为bool已经被C++用了，所以选了这个十分奇译的关讓字。在这之前C程序员对布尔类型的模拟是相当混乱的。为了在C和C++程序中以统一的方式使用布尔类型，同时提高可移植性，可以采用下面的方式

P.S. 目前仍然有很多编泽器井不支持C99的新待性，特别是比核老的編泽器，如CB6和VCB都不支持_Bool关键字

18. enum类型 #

1. 一个元素只能定义在一种enum中 # 

enum WeekDay {Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday};
enum WorkDay {Monday}; // 编译报错，因为 Monday 已经被定义了

解决方案是使用 enum class

enum class WeekDay {Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday};
enum class WorkDay {Monday, Tuesday, Wednesday, Thursday, Friday};

WeekDay d1 = WeekDay::Monday;
WorkDay d2 = WorkDay::Monday;

2. 没有++操作 # 

WeekDay day = Tuesday;day++;
//Error，No Operator ++ for day

3. 不能直接赋整型值 # 

WeekDay day;
day = 1;//Error，Cannot Convert int to enum

4. 返回值是索引值 # 

WeekDay day = Monday;
cout << day << endl; // 结果是0

5. 后一个元素的默认索引值总是前一个元素的索引值+1 # 

enum WeekDay{Monday=1,Tuesday,Wednesday=1,Thursday,Friday,Saturday=9,Sunday};

则各元素依次的索引值分别是：1，2，1，2，3，9，10

19. 数组 #

1. C++编译器不对数组下表进行越界检查 #

下图代码中越界的下标也可以编译通过

int a[4] = {1,2,3,4};
cout << a[-1] << endl; // 不会报错
return 0;

2. 数组之间不能直接赋值 # 

int a[4] = {1,2,3,4};
//int b[4] = a;//Error

20. vector类型 #

建议使用vector代替array，除非特殊情况必须使用array。

21. pair类型 #

在单个对象内部把两个类型相同或不同的值关联起来。

22. ASCII 码 #

ASCII码 从32到127为可打印字符

  • 数字0~9 为48~57
  • 字母A~Z 为65~90
  • 字母a~z 为97~122

23. limits头文件 #

定义了各种类型的边界常量。

在C语言类库中，limits.h 或 climits 中，有一些宏定义

img.png

在C++语言类库中，limits中，通过 numeric_limits<type>::max/min()，获取边界值。

24. 强制类型转换书写格式 # 

//c++
type (expr); 
double a = 1;
int b = int (a);

//c
(type) expr;
double c = 1;
int d = (int) c;

25. 复合语句 #

由{ }括起来的语句序列。

包含一条或者多条声明语句的复合语句，也称为块block或语句块statement block

26. C\C++声明是否属于语句 #

对象的定义不是C语言的语句。所以放在block的开始部分。

对象的定义是C++语言的语句。所以可以放在block的任何部分。

这就是为什么C中要先定义后使用，C++可以边定义边使用。下面一段话摘自C++ Primer

在70年代，计算机程序语言设计哲学强调这样一种美德：在程序、函数或语句块的开始处，并且在其他程序语句之前定义全部对象。（例如，在C中，对象的定义并不被视为C语言的语句，块中的所有对象定义必须出现在任何程序语句之前。出于这种需要，C程序员使自己习惯于在每个当前块的顶部定义全部对象。）在某种程度上，这是 FORTRAN 支持的动态对象定义容易出错的一种回应措施。

由于对象的定义是C++语言的一条语句，所以可以将对象定义放在任何其他语句能够出现的地方。从语法上讲，这也是使声明的局部件成为可能的原因。

27. 链接指示符 extern “C” #

之前在讲动态链接库时已经提及，以下摘自C++ Primer

程序员用 链接指示符（linkage directive） 告诉编译器，该函数是用其他的程序设计语言编写的。链接指示符有两种形式。既可以是 **单一语句（single statement）**形式，也可以是 **复合语句（compound statement）**形式

// 单一语句形式
extern "C" void exit(int);

// 复合语句形式
extern "C" {
    int printf(const char* ...);
    int scanf(const char* ...);
}

// 复合语句形式
extern "C" {
#include <cmath>
}

该文2011-04-23 13:07首发于我的CSDN专栏。有改动。