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);