C++学习笔记～

1、访问外部成员用::x=2;

2、char** p;                       //到字符的指针的指针；

3、int(*f)(char *);                //到函数的指针，这种函数以char*为参数，返回int

4、数组中如果初始赋值太少，剩余的将被设为0；

5、如果从一个指针减去另一个指针，结果就是这两个指针之间的数组元素的个数。

int i1=&v1[5]-&v1[3];                     //i1=2(必须是同一个数组的指针)

6、常量const必须初始化；

7、使用一个指针涉及到两个对象：该指针本身和被它所指的对象。将一个指针的声明用const“预先固定”将使那个对象而不是使这个指针成为常量。

如：void f(char* p)

{

char s[]="Gorm";

const char * pc= s;               //指向常量

pc[3] = '8';                            //错误：pc是指向常量的

pc= p;                                   //OK

 

char * const cp =s;                //常量指针

cp[3]= 'a';                             //OK

cp= p;                                  //错误：cp是常量指针

 

const char *const cpc = s;   //到const的const指针

cpc[3] = 'a';                          //错误：cpc指向常量

cpc = p;                               //错误：cpc本身是常量

}

 

////////////////////////////////////////////////////////////////////指向void的指针

void f(int *pi)

{

void * pv=pi;                       //可以，从int*到void*的隐式转换式

*pv;                                    //错误：void*不能简介引用

pv++;                                //错误：void*不能增量（不知道被指对象的大小）

int* pi2=static_cast<int*>(pv);                                   //显式转换回int*

double*pd1=pv;                                                         //错误

double*pd2=pi;                                                         //错误

double*pd3=static_cast<double*>(pv);                         //不安全

}

///////////////////////////////////////////////结构体

9、两种结构体总是不同的类型

s1 x；

s2 y=x；          //错误，类型不匹配

2012-11-7

定义：用于为变量分配存储空间

声明：用于向程序声明变量的类型和名字，（可以通过使用extern关键字声明变量而不定义它）

变量可以声明多次，但只能定义一次

extern double pi  //声明

double pi  //定义

extern double pi=3.14  //声明+定义

在全局作用域声明的const变量时定义该对象的文件的局部变量，此变量值存在于那个文件中，不能被其他文件访问通过指定const变量为extern，就可以在整个程序中访问

引用是它绑定的对象的另一名字，作用在引用上的所有操作事实上都是作用在该引用绑定的对象上。

2012-11-8

string是一个类string str //str是一个对象

str.empty()       //str为空返回true

str.size()         //返回str中字符的字数，是string::size_type型，不要把它赋给一个int变量，直接用。

str[n]             //返回str中位置为n的字符，位置从0开始

str1+str2          //连接成新串

vector不是一种数据类型，而只是一个类模版，可用来定义任意多种数据类型。vector类型的每一种都指定了其保存元素的类型。因此，vector<int>和vector<string>都是数据类型。

v.empty()

v.size()

v.push_back(t)      //在末尾增加

v[n]          //位置为n的元素

v1=v2

v1==v2

vector类型总是包括vector的元素的类型：

vector<int>::size_type     //OK

vector::size_type      //error

2012-11-12

int a=10，b=20；

int *pa，*pb；

pa=&a，pb=&a；

*pa=b；   //*pa=20，a=20;

pb=b；    //*pb=20, a=10;

指向const对象的指针必须也是const指针类型。

const int *p //指向const对象的指针，可以指向其他对象，但不可以改变对象的值

int *const p //const指针，不可以指向其他对象 ，可以改变对象自己的值

2012-11-13

动态分配数组 int *pia = new int[10];返回指向数组第一个元素的指针

size_t n = get_getsize();

int *p = new int[n];

for(int *q = p;q!=p+n;++q)

/process the array/

delete [] p;

string str2;

char *str=str2.c_str();//c_str函数返回c风格字符串

int int_arr[6]={0,1,2,3,4,5};

vector<int> ivec(int_arr,int_arr+6);//用数组给vector赋值，第二个指针指向被赋值的最后一个元素之后的地址空间

int ia[3][4] = {{0},{4},{8}};//给数组的每行第一个元素赋值

int *ip[4]    //指向int型的指针数组

int (*ip)[4];  //指向包含4个元素数组的指针

typedef int int_array[4]            //   =typedef int[4]  int_array;

int_array *p =ia;             //指向包含4个元素数组的指针

21%5==-4

int i = 0,j;

j=++i;            //j=1,i=1;            ++i返回对象本身，这是左值

j=i++;            //j=1,i=2;             i++返回右值，i要后面才能计算出来。

2012-11-14

处理复合表达式

（1）如果有怀疑，则在表达式上按程序逻辑要求使用圆括号强制操作数的组合。

（2）如果要修改操作数的值，则不要在同一个语句的其他地方使用该操作数。如果必须使用改变的值，则把该表达式分割成两个独立的语句：在一个语句中改变该操作数的值，再在下一个语句使用它

输入ctrl+z后可以在后面添加cin.clear()继续输入。

2012-11-30

inline 内联函数，将函数指定为内联函数，（通常）就是将它在程序中的每个调用点上“内联地”展开。相当于直接把函数中的代码复制到调用的位置。能够节省开销。

2013-3-6

用vector存储派生类的对象时，会截去派生类中的部分，只保留基类部分，如果想要保存派生类中的部分，应该用vector存储对象指针。