C++学习点滴1

基于《c++ primier》第三版

 

1. 基于对象--> 封装
   面向对象--> 继承、多态

2. 算法的概念不要局限于某些数学算法(排序、遗传算法之类的)，只要是对带求解问题的解决步骤的描述，都可以称为算法。

3. c++最小的程序单元式语句(statement):
    声明语句(declaration): 如int i = 0;
    赋值语句(assignment)：如i=100;
    输入/输出语句：如cout<<"hello world";

4.函数=函数原型+函数体
  函数原型=返回类型+函数名+参数列表

5. C++从main()函数开始执行。
  标准C++中，如果main函数没有return语句，则缺省返回0，表示OK。

6. include <xxx.h> // 标准头文件，从预定义目录搜索
   include "xxx.h" // 用户提供的头文件，从当前目录开始搜索

7. 头文件一般如下定义：
   #ifndef XXX_H
   #define XXX_H
   // 。。。
   #endif

8. 几个预定义常量：
   __cplusplus 和 __STDC__ ：两个只能出现一个。前者是编译c++生成，后者是编译标准C生成
   __LINE__和__FILE__：当前编译的文件名和当前被编译行数
   __DATE__和__TIME__：编译日期和时间
   其中__LINE__和__FILE__会再编译期间变化，其他四个不变:
   #ifdef __cplusplus
    cout<<"c++\n";
    #endif
    cout<<"file: " << __FILE__ << endl
        <<"line: " << __LINE__<<endl
        <<"date: " <<__DATE__<<endl
        <<"time: " << __TIME__<<endl;

9. c库文件引入时无需使用using语句如#include <assert.h>，但是c库文件对应的C++文件引入时
需要使用using指令，如#include <cassert>  using namespace std;
  
10. 字符串输入(多个字符串之间用空格隔开)
    string s;
    cin>>s;
    cout<<"s=" + s<<endl;
   
    string s1, s2;
    cin>>s1>>s2;
    cout<<"s1="<<s1<<"; s2="<<s2<<endl;
 
    string cnt;
    while(cin>>cnt){
        cout<<"content: "<<cnt<<endl;
    }

11. 内存泄露
  是指一块动态分配的内存，我们不再拥有指向这块内存的指针，因此我们没有办法将它返还给程序供以后重新使用。
 
12. 静态分配和动态分配：
    int k = 8888; // 静态分配
    int *pk = new int(8888); // 动态分配
    int *pkarr = new int[10]; // 数组的动态分配
    cout<<"k="<<k<<endl;
    cout<<"*pk="<<*pk<<endl;
    delete pk;
    delete [] pkarr;
    cout<<"k="<<k<<endl;
    cout<<"*pk="<<*pk<<endl;  // 此时pk指向的内存已经被回收，该块区域可能为任何值

13. 类定义中的成员函数会被自动当做inline函数

14. 数据类型：
   char:  'a', L'a'(宽字符)
   short
   int:   20, 024, 0x14, 20u
   long:   20UL, 20L, 8LU
   float:  3.14F, 0.1f,
   double:  0.0, 3e2, 1.0E-3, 2.
   long double:  3.14L
   bool:   true false

15. 左右值
  对于每一个变量，都有两个值与其相关联：
  * 它的数据值。或右值。被读取的值。文字常量和变量都可以被用作右值。
  * 它的地址值。或左值。文字常量不能用于左值。
 
16. 初始化
  int i = 100;
  int i(100);
  int i = int();  // 初始化为0
  double d = double(); // 初始化为0
  string s = "xxx";
  string s("xxx");
  string s; // 调用默认构造函数
 
  对于基本类型的全局变量，初始化为0，而它们的局部变量不会被初始化。

17. 指针：存储的是地址值。
    * 初始化：
      int *pi = 0; // 不指向任何对象
      int *pi = &i; // 取地址
      int *pi = pi2; // 指针互相赋值
      int *pi = i; // error. 不能把整形变量赋给指针。
      double d = 1.0; double *pd = &d;
      int *pi = pd; // 不能跨类型给指针赋值
     
      void *pv = pi;  // void类型的指针可以被任何类型的指针赋值
      pv = pd;
     
      // 读写指针所指向的对象
      int i1 = 100, i2 = 200;
      int *pi = &i1;
      *pi = i2;
      *pi = *pi+1;
      *pi = abs(*pi);
     
      int **ppi = &pi; // 指针的指针
      int *pi2 = *ppi;
      cout << i << " -- " << *pi << " -- "
          << **ppi << " -- " << *pi2 << endl;
     
     
      // 有些不能转换的情况
      int i1 = 100;
 int i2 = 200;
 double d =3.14;
 int *pi1 = &i1;
 int *pi2 = &i2;
 int **ppi3 = 0;
 int **ppi4 = &pi1;
 double *pd = &d;

 i1 = i2;  // ok. int-->int
 //i1 = pi1;  // no. int*-->int
    //i1 = ppi3;  // no. int**-->int
    //i1 = pd;  // no. double*-->int
    //pi1 = i1;   // no. int-->int*
    pi1 = pi2;  // ok. int*-->int*
    //pi1 = ppi4; // no. int**-->int*
    //pi1 = pd;   // no. double*-->int*
    //ppi3 = i1; // no. int-->int**
    //ppi3 = pi1; // no. int*-->int**
    ppi3 = ppi4; // ok.int**-->int**
    //ppi3 = pd;  // no. double*-->int**

 

18. bool类型
  // bool变量本身只有true和false两种值
 bool b1 = true;
 bool b2 = false;

 // 可以把bool变量赋值为int类型
 int i1 = b1; // 1
 int i2 = b2; // 0
 cout << "i1=" << i1 << "; i2=" << i2 << endl; // i1=1; i2=0

 // int类型和指针类型可以赋值给bool变量使用.
 // 0和空指针赋给bool时为0，非0和非空指针赋给bool时为1
 int i3 = 100;
 int i4 = 0;
 bool b3 = i3, b4 = i4;
 cout << "b3=" << b3 << "; b4=" << b4 << endl; // b3=1; b4=0

 int *pi1 = &i3, *pi2 = 0;
 b3 = pi1; b4 = pi2;
 cout << "b3=" << b3 << "; b4=" << b4 << endl; // b3=1; b4=0

 // bool变量、int值、指针都可以作为bool表达式进行判断
 if (b1 || i1 || pi1) {
 }

19. 常量
  int i1 = 100;
 const int i2 = 200;  // 常量
 //int *p1 = &i2; // error. 常量的地址只能赋给常量指针
 const int *p1 = &i2;
 //*p1 = 1000; // error. 不能修改常量指针所指向的变量值
 p1 = &i1; // 常量指针的微妙之处是指针本身的值可以重新赋值
 //*p1 = 1000; // 无论常量指针指向的是一个常变量还是一个普通变量，都不能通过指针修改其所指向的值

 // 指针常量
 int *const p2 = &i1; // 指针常量只能指向指向普通变量
 //int *const p2 = &i2;   // 不能指向常变量
 //p2 = &i2;          // 指针常量的微妙之处在于指针本身是个常量，不能再修改它是它指向别的变量
 *p2 = 1000;   // 但是指针常量指向的值可以修改

 // 常量指针常量
 const int *const p3 = &i2; // ok。可以指向常变量或者普通变量
 //p3 = &i1; // 不能修改指针
 //*p3 = 1000;  // 不能修改指向的值

 

20. string对象
  string s1(""); // empty string
  string s1("Hello world");
  string s2(s1); // 拷贝构造
  string s2 = s1; // 赋值
  string s3 = s1 + s2; // 用+连接
  s3 += s3; // 用+=连接
  if (s1==s2) {} // 比较
  int cnt = s1.size() // size()函数
  if (s1.empty()){} // empty函数
 
  // 和c风格字符串互操作
  string s("aaaxxxbbb");
 const char *pstr = s.c_str(); // 返回的是一个指针常量
 cout << pstr << endl; // aaaxxxbbb

 char *ps = "xxx";
 string s1("aaa");
 string s2("bbb");
 string s3 = s1 + ps + s2;
 cout << s3 << endl; // aaaxxxbbb
 
  // 下标操作
  string s("aaaxxxaaa");
 int size = s.size();
 for (int i = 0; i < size; i++) {
  if (s[i] == 'x') { // s[i]是一个char类型
   s[i] = 'yyy';
  }
 }
 cout << "s=" << s << endl; // s=aaayyyaaa

 

21.引用
  引用是对象的别名。
  int i1 = 100, i2 = 1000;
 int &r1 = i1, &r2 = i2; // 定义时必须被初始化。一旦初始化，就不能再指向别的对象。
 r1 = 200;  // 常量-->引用。实际上是给i1赋值
 cout << "i1=" << i1 << endl;
 r1 = i2;  // 变量-->引用
 cout << "i1=" << i1 << endl;
 r1 = r2;  // 引用-->引用
 cout << "i1=" << i1 << endl;

 //int &r = 100; // 不能用文字常量给非const的引用初始化
 //int &r = i + 100; // same above
 const int &r = 100; // ok. 可以把文字常量给const引用初始化

 double d = 3.14;
 const int &r3 = d;  //ok. 可以快类型给引用初始化
 //int &r3 = d; // error. 前面必须加const关键字

  // 引用最常用的地方是作为函数的形参
  void test(const int &i) {
    cout << i << endl;
  }
  调用： int i = 100; test(i);