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 = π // 指针的指针

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