C++编程经验总结1

面向对象的精髓：

主函数其实就是对于类的元素和动作的重新组合来进行一项活动。

一个思想概念：程设是清楚的，完美的。

数学是清楚的，是完美的。

物理是有趣的，尤其是量子物理

生物是清楚的，尤其是基因

外语是完美的，……

*******************************************************************************

外界的调用  成员函数  protect的不能被外界调用，但是可以是子类调用

限定符   对象的定义和结构体一样，可以附在后面  默认是私有的（Private）

类中的成员函数之间可以调用的

在类外定义成员函数，但是在类内部要首先及进行申明

：：作用域限定符   全局函数

Inline内置函数（其实是把简单的代码段嵌入进来）

成员函数指定为内置函数的方法   头文件

其实是与OS交互的语言，内部的编译调用理解的

This指针    成员函数在存储上其实和对象是分离的

通过对象的引用变量来访问对象的成员

定义引用变量

time t1;

Time &t2=t1;

定义类的对象的方法一般是在主函数里

主函数运行的过程其实就是多个对象在行为而产生的时空状态的改变 （其实就是通过一个个消息）

头文件里是类的定义，但是没有类里函数的定义，防止成员函数闭多次调用要经行多次编译

类库

类对象的初始化有一种是和结构体很像的 time t1={14,15,16}; 14 15 16分别对应类的变量

含有主函数的类就是主类，要运行一定有个主类

一个类里要设计自己的变量的set函数吗。不需要

构造函数（与类同名字函数）它是特殊的成员函数

构造函数的内容自己设计

构造函数当然也是可以在类外定义的，和普通的成员函数一样，但要记得在类内申明

构造函数也像消息一样，用于改变状态，无返回值

类有构造函数是必须的，当定义一个类对象时，就会调用构造函数，并会有初值，然后通过交互改变初值，但是其实还是有交互函数set()  show()

C++程序的结构就是：有#（用于包含系统文件进来）

有多个类及其内部结构

有一个主函数，一般主函数是在最后

******这些是顺序关系，用于改变计算机时空状态，这是程序运行的结果

要深入领会程序不同写法之间的区别

构造函让主函数简单，主函数里面不需要定义函数

构造函数不能被调用，在定义对象的时候自己自动执行

构造函数可以带参   在类外经行定义构造函数

构造函数的参数在对象定义的时候给出

参数初始化表:

box(int h,int w,int len):height(h),width(w),length(len) { }  //注意后面的{}不能省

类可以由多个构造方法，但是名字都是一样的，就是重载

默认构造函数 （缺省构造函数）

构造函数的默认参数

默认参数构造函数是不能重载的

析构函数：对象结束时候自动执行的  ~box()

对象的全局和局部

题目是什么，其实就是知识的变相啊

一个类只能有一个析构函数

析构函数是类必须有的，可以自己设计，可以补充

析构函数就是插销对象的内存之前做的工作，完成清理工作

Static局部对象在函数调用后不释放，所以不进行析构 ，而只有在mian 或是exit函数调用后使用析构

在一个函数中定义一个对象，调用结束时则进行析构函数

有全局对象的析构，析构是作用域完成时候才会调用

用new创建一个对象时，用delect释放内存时，自动调用该对象的析构

当显式的定义析构函数时候，对象执行之后会显示出来

默认的时候是不会显示出来，其实析构函数的总是存在保证了内存的安全保障

析构函数的调用和构造函数的调用是栈结构，顺序是相反的（对象的作用域是很重要的，根据作用域的不同，又是不一定的）

复制构造函数  转换构造函数

可以有静态对象

对象数组 （多个对象组成数组）

Student stud[3]; 类的对象数组

对象的构造函数的参数若一个，则：

Student stud[3]={3，4，5}；

指针可以指向对象（对象指针） Time *pt;  //指向类的指针

(*Pt).hour   pt->hour是一样的效果，指向对象的成员变量hour

定义一个函数指针 void (*p) ( );

P=fun;

(*p)( );//通过指针调用fun函数

Void （Time：：*p2）( );//定义指向成员函数的指针

P2=&Time::get_time;//给该指针赋值   ***这两句可以合一

This指针，是在成员函数里的指针，指向本类对象  this可以是显式写一般是隐式（编译系统补充的）

常对象  Time const  t1(12,34,46);

常对象不能调用其他非常成员函数

常成员函数  void get_time( )  const;

Mutable int count; //这时候就可以用常成员函数来修改该数据变量了

指向对象的常指针  指向常对象的指针变量   指向常变量的指针

Const Time *p=&t1;       const char  *p;

Time  &t   //t是time对象的引用   const  Box&b;

New box；//动态建立对象，这个对象存在但是不能用，是无名对象，它的返回值是指针

，通过指针来访问这对象

对象之间的赋值  t1=t2;  对象之间的赋值只是成员变量，不是成员函数

Box box2(box1);

或者 Box box2=box1;

复制构造函数是隐形的

类中的静态数据成员代表产生的对象的该属性是一样的

静态的就是公共的。

静态数据成员可以用类名或者是对象名来引用

静态成员变量在类外部初始化，不能通过参数初始化表初始化

Int  Box::length=3;

静态变量是在类层次的

公用的成员函数可以引用静态变量

可以在函数中定义类   静态变量起了全局变量的作用，但是和全局变量不同，要好

静态成员函数的调用

Box::volume();

A.volume();

静态成员函数的作用就是处理静态变量

默认情况下，静态成员函数不能访问本类中的其他非静态成员

成员函数都有this指针，但是静态成员函数没有

友元函数 友元类

友元函数在类外定义，在类内申明， friend void display( );

这样该函数就可以访问类的私有变量了

友元可以是其他类的成员函数

* (&a)=* p   实际是a的值

内存寻址方式  void *p=&a;

常量指针  int  *const p;

常引用 const int &ra=a;

指向常量的指针常量 const int * const p=&a;

逻辑 关系 条件   提取符和插入符  插入运算符的级别低  endl=’\n’

Cout<<oct<<a<<’+’<<b<<’=’<<c<<endl;  八进制

顺序  选择 循环

Goto  niu;

Niu:  *****;  他们在同一个函数体中

匿名对象   内联函数

返回引用类型的函数  int & max(int &a,int &b);

CFC 命名空间using namespace  std;   浩强工作室  未名湖畔  清华园

类型识别（RTTL）   虚函数

#include <iostream>

Using namespace std; （其实就是包）

Int main()

{   cin>>a>>b;

Cout<<”this is a C++\n”;   <<插入运算符  cout是流对象

也可以用printf(“****”);

Count<<” ”<<sum<<endl;   endl（换行）  输入必须空格控制输入参数

Return 0;

}

类和函数都是在std命名空间里的

Class student

{private:

****

Public:

*****

};

友元类 控制流setw(6)————iomanip

C++输出输出其实是串控制的形式

Const　int  a=2;

函数原型的申明简单了

Sealed   explicit   gcnew  nullptr   generic   literal  MFC

主函数中类类型的变量就是对象  智能的语言都是大小写敏感的C \c++

5UL无符号长整型

枚举类型变量:

Enum  color(red,yellow,blue);

Int main()

{color  c;

c=red;

}

E  e是一样的指数   f为单精度 e为双精度  L为双长精度

‘\0’表示空字符  \ddd=\xhh

八进制 16进制

\\表示反斜杠   “niuweiqiang”是字符串

转移字符之前加\，就会不冲突

字符串的储存一定是后面自动有\0

函数模板（template）

Template<typename  T,class  T1>;

T max(T a,T b)

Alias别名 引用（变量的别名）  int &b=a;(b为引用变量，引的是a)

引用变量感觉有点像指针   引用比指针好

引用不能有指针变量   数组没有引用

内置函数（内嵌函数，内联函数）  inline  int max(int a,int b)  不再进行宏定义

Const

作用域运算符：：   ：：a表示访问全局变量

#include<string>

字符串类型变量 string string1;（类名 对象）

字符数组存放字符串  strcat()  strcmp()  strcpy()

字符串类的对象     字符串数组

New int(100);开辟空间，整数初值100，返回值是指针

Delete [] pt;撤销空间

New  delete是运算符，不是函数

条件编译

#if  ***//表达式非0，则执行第一句

……

#else

……//第二句

#endif

联编

#ifndef  标识符

#define  标识符

……

#endif    //标识符已经被定义，则忽略，没有被定义，则执行……

一般申明和定义分离

Extern int a;表示变量a的作用域在几个文件中

Static只是在本文件中

命名空间就是对象极其相关的集合，可以理解为地域区域。

Using  namespace  std;

命名空间是相对于头文件而言的

命名空间里面有元素（元素就是类 函数  对象）

名空间其实就是文件管理里的，相当于C的扩展名，.h什么的

当然扩展式的作为补充可以要，当空间里没有这种头文件时

Using  std::cin;  //指定使用std的元素cin

可以自己定义命名空间

Namespace  mingmin1

{

Class  niu{

……

……

}；

函数1；

函数2；

}
using namespace  mingmin1;

Using mingmin1::niu; //使用命名空间

包含命名空间 #include “mingmin1.h”

#include<cstdio.h>  //C格式变为C++格式

Abort  assert   exit

Void **(int  status或void或expression) //**为这三个，终止执行

匿名对象  嵌套调用（调用别的函数）  递归调用（调用自身）

直接递归  间接递归   堆栈

Fibonacci   函数指针

Typedef  Double  (*p) (double ,double);

Typedef   Functiontype *p;//都是定义函数指针typedef可以省略

P=max;

X=p(0.1,0.3);

函数指针还可以作为参数    函数指针还可以调用库函数

内联函数（内置函数）节省函数调用开销  内置函数是简单函数

内置函数在类外前定义

函数调用的过程其实和中断有点像。都要用栈机制来保存现场

函数重载只是参数列表不一样，其他的是一样的

应用程序（项目/工程）——多个文件

自动存储 auto（register）  int x,y;//是默认的

全局的标识符默认为extern    extern也表示静态的

static的局部变量只能定义在函数体内使用  静态的变量程序一执行就是都存在

标识符作用域的可见性

文件作用域就是大的作用域（全局变量）

头文件    文件结构

预处理指令（可以在任何位置）  预处理文件

#incude< >

#include’ ‘

C++安装的时候就把库文件来下载了   盘符

可以自己写头文件  宏定义#define  pi  3.14

友元成员函数

Friend  void  time::diaplay(data &);  //time类的diaplay函数为本类的成员函数

一个函数可以是多个类的友函数    可以提前引用申明类

友元类  友元关系是单向的不能传递的

Friend niu;

函数模板

Template<class int>         类模板是类的抽象

Compare<int>cmpq(3,7);     模板类是类

在外部定义模板函数

template<class numtype>

Numtype compare<numtype>::max( )

{return (x>y)?x:y;}

Static int niu[4];   //初始化的时候都为0

Const int niu[3];   //初始化后不变

数组的下标越界访问是很危险的

通过指针访问数组    数组名就是数组的首地址   MSDN

字符串变量

指针数组  int *p[3];

指向数组的指针数组  int (*p_niu[3])[ ];

指向函数的指针是可以调用函数的

Typedef int ftype( );

Ftype   *pmax[3];

Int   (*max[3]) ( )

Pmax[1] ( )  用指针调用函数数组的第一个函数

用指针访问数组

Int *p=New int(0);

Delete p;     //动态分配和收回内存

结构体类型的指针变量（指向结构体的指针）

结构数组

Struct People

{

Int a;

Double x;};

People niu[3];  //niu为结构数组

索引和顺序映像     链表要用到结构

josephus环问题（用到动态链表机制来实现）

编程的本质就是数据的组织和运行规则的制定。

类是数据类型   struct也可以定义类，但是不常用，而且一般定义的都是共有的成员

.和->效果一样

This指针指向对象的地址（因此可以把this看做是一个自身对象）

this是成员函数的指针参数

This指针不能显式说明，但是可以显式使用，而且是常指针

成员函数的参数可以是指调用自己的对象

常函数（函数的this指针指向常指针（指向常变量））

复制构造函数   Time:Time(const  Time &p，int =1); //引用名可以为空

深复制（自定义复制函数）  浅复制（默认复制函数）

STL源码分析     类是一个数据类型   类属

运算符函数

Void  Time::operator ++(int a,int b)

{

……

}

运算符其实是一个函数   运算符函数的重载可以是成员函数和友元函数

操作对象为类的时候就辉重载运算符函数

重载函数都是了类的

流插入<<  流提取>>   cout  cin为对象

类类型转换函数   类类型的转换

制造C++语言的这些人好厉害啊，规则是什么都记不住啊。对于语言的实践有没有必要深入的研究的精通。 是的，要精通，深入研究总会理解的。道理懂了之后一定要会用。

2017   5.19    Lanzhou  in China