C++学习总结一

1.  ifstream in ("a.txt");

a. for(int a; in >>a..)  //流一次读入一个字符

b. for(string str ; getline(in ,str);)..//流一次读入一行

 

2. char的运算与int可是为一样

3.char*（char串）和字符串数组类型不同，但是操作上基本一样，都表示C-串的启示地址（但是char*的结尾有个空字符，表示结束）

4. 

a. 逐字输入  cin.get()

b.  逐行输入 cin.getline()

5.  常量,eg:  const int a=7;  //编译期间就可以确定

      

6.

a.  int a[ ]={1,2,3,4,5}

sizeof(a);  //计算a 的空间大小

b.  sizepof(a[0])  //计算元素a[0]的空间大小，结果以字节为单位

 

7.  vector,使用下标([n]),和inerator都可以进行操作

8. c++中cast强转操作方式：

a.  int*  ip=(int*)&f;  //

b.  double ip=double(5);   //只有内置类型才有此种方式

 

9.  

a.  引用类型就是一种隐性指针，指针自身地址就是所操作的实体的地址，

b. 且与指针最大的区别是引用不能修改自身的地址，也就是说引用赋初值后就不能改变了

 

10.   *s++=*s2++  //后增量++就是在 本语句结束后执行的，所以虽然是先++后*，但是由于是后增++,所以s1，s2指针没变

11.

vector<int>  add(..)

{

  vector<int> c (a.szie);

   reurn c;   //函数返回时，如果不是引用和指针，就要做对c进行copy，产生一个临时量，当函数被调用处的表达式结束后，该临时量也就消失了

}

 

12. 函数的声明和函数的指针

int g(int);  //函数的声明可以省略参数名和函数体

int (*gp)(int) ;  //该函数指针为形参的类型是 int(*)(int);   这样定义只是定义了一个函数指针实体，并没有定义函数指针的类型(定义函数指针类型要使用typedef）

typedef int (*fun) (int a);  //这样才是声明一个类型为int(*) (int)的函数指针类型

 

13.  函数声明的形式

a.  int a(int) //可以省略形参名，

b.  int  (int) //函数名和形参声明都可以省略(成为无名函数)

// a只是一种函数的类型，b做函数的声明，也做函数的类型

 

14.  bitset<100> *  p=new bitset<100>;

a.  p->set() //一般指针所指对象调用对象内部方法，成员

b.  所以不用对对象内部成员操作一样先 (*p),然后操作

 

15.  栈空间很宝贵，大数据运算-->使用堆空间

16.     .cpp文件中只对引用到的函数或者类型进行include

17.  全局数据和函数一样只能一次定义，但是可以多次声明， 一般在头文件中声明为 : extend int n=8;

18.

a.  const int a=3;  // 是文件域的，可以在多个文件中重复定义，但在同一个文件中不能重复定义

b.  extend  int  n=8;  //  是程序域，的就不能重复定义

 

19.  作用域就是名空间，

20.  对的作用域是整个程序范围，使用new申请到的空间,

 

21.  C++中名空间的定义总是放入头文件中，eg:

  a1.h

  namespace  a1{

  void  f1(  );

  }

 

22. 

a. 模板定义，全局常量，inline函数，类定义，enum定义，都要使用

# ifndef   DATE

 # define  DATE

struct  DATE{ int year,month,day;};

#  endif  //头文件卫士来防止重复声明

b.  a中的全部定义都可以放入头文件中，函数的实现(定义)除外，

c.  a中的定义都可以在不同的文件中重新被定义，（因为属于内部链接）

 

23.  常成员函数不改变对象的值，  void  print( ) const;

24. 

point a,b,c

point d=a+b+c  //重载的point类型的operator +,返回一个临时的point(a+b的值)参与与C的相加，当该行表达式结束时，该临时point销毁

 

25. count<<a <<b //<<左结合性(从左-->右)返回当前的流，所以可以一直操作

26.  ostream & operator<<(ostream & o,const point & d)

{

 return  o<< ..;     //重载<<,必须返回&（引用），否则会拷贝返回一临时数据

}

 

27.  类和函数的实现与定义可以分开实现，

a. 但是类型实现的cpp中要包入相应要实现的类的头文件，

b. 函数实现文件cpp,中不需要包入相应的头文件

 

28.  成员内联函数，一般都直接写在类定义内部

29.  静态成员不能放在头文件中，应放在类实现中，（类外实现）

30.  其实函数的实现放在任何cpp中都可以，但是要明确是为那个.h的函数进行的实现，如有同名的函数声明则应该在实现的cpp中，加上名空间，

名空间::fun(){  };

31.  DATE  g;  // 无参对象定义

      DATE  f();// 返回类对象的无参函数声明（是个函数的声明），

32. 

a. 在构造函数体中，不能完成对常量成员和引用成员的初始化，

b.如果，构造函数的初始化器中没有为成员进行初始化，也未在构造函数体中进行赋值，则调用该成员的默认构造函数进行构造

 

33. 静态对象是文件作用域对象

34. 指针的空间有类型：指针所指的空间只能放入与指针类型相同的数据，否则要动态强转：  reinterpret_cast<..>

35.

class silly  {

const int ten ;

int& ra;  // 相当于在代码区已定义和声明引用ra,常量ten，（先于构造函数）

public :

  silly(int x,int& a) //构造函数属于二次定义，所以对于常量和引用会有问题，但是在构造函数初始化表中再次初始化没有问题，相当于在代码区的构造阶段

  {

     ten=10;

     ra=a;

  }

}

36.

a.  析构函数与拷贝构造成对出现

b.  形参和实参是拷贝构造的过程//good！

c. 一般赋值拷贝和拷贝构造以及析构函数时同时产生的

 

 

37.  一个对象在构造的时候

a. 首先构造其基类，如果其构造函数中有基类的初始化列表，则按初始化列表参数来构造，否则调用基类的无参构造函数

b.  然后在构造函数调用前，先分配对象的自身空间，全部子对象（成员），按初始化列表进行构造（没有初始化表的，调用其默认的构造）

c.  最后才执行自身的构造函数的本体

 

38.

C++在使用任何东西之前都要先声明，但是只声明“所用到的东西”即可，eg：

class A :public  class  B //在使用 class A的场合只要包入Class  A的头文件即可

 

39. 多态，

GraduateStudent  gs//继承于student

a.  student s=gs;  // 只是拷贝gs的基类部分，将gs转换为基类s

b.  student&* t=gs;

c.  student* p=&gs;

a中把子类中基类部分进行了复制，  b中引用t代表gs中不可分离的基类（student类）的部分。多态只能使用引用或者指针实现

 

40.  要实现多态，必须加上virtual（成员函数，否则不会实现多态）

41.  int* p=static_cast<int *>(malloc (100)); //将局部的堆空间转换为整型数组空间，指针类型的转换，只是告诉编译器用什么类型来识别该空间

42. 

a.  static_cast 不只针对指针转换，只要是相关的类型都可以转换

b.  对有virtual继承的多态转换由dynamic_cast实现(一般针对多态的指针)，

 

43. 虚函数的子类和父类的同名函数中，返回类型可以不同，

44. 子类若不override抽象类的纯虚函数,则仍为抽象类（反之为具体类）

45. 抽象类不能创建对象，但是可以使用其的引用和指针

46.

IDATE&  create(int y)

{

return *new DATE(...)  //先New，后*（间引）

}

a.  返回引用类型的结果，其返回就值就不用拷贝（不会产生一个临时量，或者无名量，该无名量放入寄存器中，参与表达式的其他计算，直到本行结束）

b. 但是若返回只为引用类型，应该返回堆中的引用（用new创建的），栈中的局部量都会被收回；//堆中创建的东西不会随着函数收栈而消失

c. 堆中申请的控件必须被delete（使用完以后）

 

********************************模板********************************

47. 模板类型参数没有隐式转换之说，必须精确匹配，eg：

template<typename T>

void  swap(T&a,T&b){...}  //a与b在模板实例化时，类型必须相同（因为是预编译阶段就要确定）

 

48. 使用

a.  static_cast<  >

  dynamic_cast<  > //进行转换操作比较安全，不会报错，最多返回值为0

b.  但是用普通的强转不会成功的话就会报错

 

49.

 

 T*  const& max( T*  const& a, T*  const& b)

{

  // T* （指针)加上&(引用).则直接使用实参指针，而不拷贝构造

//T*  const& a其实就是T类型指针的引用

}

 

 

50.

a.  形参  const int a //是字面常量,比如5,6

b. const  int&  a //为常量引用（是变量，只是限定该变量不能被改变）  ,*和&在类型定义时都紧跟类型后面（good！）

 

51.  模板本质不是类型，不能作为形参的类型

52. 模板铸件可以视为类模板的子类模板，例如：

template <typename T>

class A<T,T> 是template<typename T1,typename T2>

class A{...}的模板的铸件

 

53.  异常

a. dynamic_cast<check& >的转换类型，若为引用，则转换失败后抛出bad_cast异常

b.  若转换对象为指针，eg：dynamic _cast<check *>,转换失败后，返回0

 

54.  可以使用typeid进行类型比较，eg：

class A; 

A a;

if(typeid(A)==typeid(a))  //进行类型比较，可以是对象，指针或者引用

{

}