c++

一
1.递归 回溯
2.欧几里德算法
3.快速幂
4.binaryPow 二分幂
5.全排列问题
6.记忆化处理

7.stl 标准模板库
8.struct {数据类型1 成员名1}变量名 结构体
定义完结构体加；
逐项输入
一般不能整体使用 都是对结构体成员进行使用
9.重载运算符operator 重新定义运算符
sort排序 由高到底 sort（a+1，a+n+1）；
10.标准库类型string 字符串类型 （对象） 可变长度
需要头文件
string s4（“i am”）可以这样用
s4.size（）求字符串长度
getline（cin，变量）可以有空格 不可回车
while（cin>>word） 无效输入结束
stringObj.empty判断string对象是否为空
whlie 给同一变量 输入不同值
s1.c_str()把字符串内容转化为字符数组
char pi 指针指向变量的类型
&ival & 是取地址符
pi=&ival pi指向ival
new 类型（初始值）分配单个对象
连续分配多个存储对象 new 类型【数组大小】
定位new new 指针类型
int ip1=new int（512）
int ip2=new int
ip2=512
delete 指针 释放单个对象
delete[] 指针 释放分配的数组
type& 别名=变量名
引用绑定而指针可以指向多个同类型的变量地址
可以有空指针但没空引用
指针直接赋值会改变指针指向而引用绑定的对象不变
const 类型 cp 指针变量cp指向常量
类型 const cp 指针常量cp
const 类型 const cp
a[i]=(a+i)
类包括行为和属性两部分（用户自定义数据类型）
类的定义格式：
class 类名
{
public:
公有数据成员和成员函数
protected:
保护数据成员和成员函数
private:
私有数据成员和成员函数
};分号不能省略
各成员函数的实现;
类的名称一般第一个字母大写
成员函数公有化 数据成员私有化
类与结构体的区别：类的数据成员私有 而结构体公有
类的数据成员可以是其他类的对象
成员函数可以操作的对象 1.数据成员 2.函数内定义的局部变量3.全局变量（不建议）
类的成员函数通过操作数据成员实现功能
一般将成员函数声明为函数原型，在类外具体实现函数
返回值类型 类名::成员函数名（参数表）
{
函数体
}
class Point
{
public：
float GetPointx();
float GetPointy(); //取得数据成员set函数是设置数据成员的值
void initPoint(float PointA_x,float PointA_y); //实现初始化的构造函数必须有
void move(float New_x,float New_y); 实现相应功能的函数
private:
float P1_x,P1_y;
}; //分号不能省
在类外实现函数功能的具体样例
void Point::InitPoint(float PointA_x,float PointA_y)//::限定必须在Point类内才可调用
{
P1_x=PointA_x;
P1_y=PointA_y;
}
对象是类的实例或实体
对象成员访问包括：1.对象名.公有成员 2.对象指针变量名->公有成员
如果操作需要从外部引入数据的话加形参 如果只对成员函数操作不用形参
类的定义和使用注意的问题：
1.类的定义中不能对数据成员进行初始化
2.类的任何成员都必须指定访问属性
3.类的数据成员可以为c++的任意数据类型
4.类的成员可以是其他类的对象
函数重载:函数名相同，但参数不同
成员函数是可以重载的
例：int abs(int a);
double abs(double f); //根据使用场景加载不同的函数
内联函数 inline 作为代码直接使用
构造函数名与类名相同
当对象创建时，系统自动调用构造函数
构造函数可以重载
构造函数可以有任意类型的参数 无返回值
析构函数用于取消对象的成员函数（当一个对象作用结束时，系统自动调用）
析构函数名为~类名
析构函数没有参数也没有返回类型
默认构造函数 类名::类名（）{}
构造函数初始化成员有两种方法：1.使用构造函数的函数体进行初始化2.使用构造函数的初始化列表进行初始化
类成员的初始化顺序：按照数据成员在类中的声明顺序进行初始化，与初始化成员列表中出现的顺序无关
初始化例：
#include
using namespace std;
class Box
{
public:
Box(); //定义了全部带默认值的构造函数，不能再定义无参 构造函数
Box(int h=10,int w=10 , int l=10); //只能在声明时指定默认值
int volume();
private:
int height,width, length;
};
this指针：当参数与成员变量名相同时，如this->x = x，不能写成x = x
使用方法 void set_x(int x) { this->x = x; }
this->x为数据成员 而x为形参
复制构造函数 格式 类名 :: 类名（const 类名 & 引用名 , …）；
1.复制构造函数名与类名相同，并且也没有返回值类型。
2.复制构造函数可写在类中，也可以写在类外。
3.复制构造函数要求有一个类类型的引用参数。
4.如果没有显式定义复制构造函数，系统自动生成一个默认形式的复制构造函数。
#include
using namespace std;
class Box{
public:
Box(int =10, int =10, int =10);
Box(const Box & b)
{height=2b.height; width=2b.width;length=2b.length;}
int volume();
private:
int length, height, width;
};
浅复制与深复制：浅复制只复制数据成员而深复制既复制数据成员又复制相应的资源
浅复制：
Person::Person(char* name1,int a,double s)
{
name=new char[strlen(name1)+1];
strcpy(name,name1);
age=a;
salary=s;
}
深复制：
Person::Person(const Person& P0) //复制构造函数的实现
{
name=new char[strlen(P0.name)+1];
strcpy(name,P0.name);
age=P0.age;
salary=P0.salary;
cout<<“ff”<<endl;
}
常成员：const int M; M被初始化后再无法被改变
公有访问权限的静态成员，可以通过下面的形式进行访问
类名::静态成员的名字
对象名.静态成员名字
对象指针->静态成员的名字
在静态成员函数内部，直接访问
例：
#include
using namespace std ;
class counter
{ static int num ;
public :
void setnum ( int i ) { num = i ; }
void shownum() { cout << num << ‘\t’ ; }
} ;
int counter :: num = 0 ; //静态成员的访问
int main ()
{ counter a , b ;
a.shownum() ; b.shownum() ;
a.setnum(10) ;
a.shownum() ; b.shownum() ;
cout<<endl ;
}
友元函数：
如果在本类（类A）以外的其他地方定义了一个函数（函数B）
这个函数可以是不属于任何类的非成员函数，
也可以是其他类的成员函数，
在类体中用friend对其（函数B）进行声明，此函数就称为本类（类A）的友元函数。
友元函数（函数B）可以访问这个类（类A）中的私有成员
运算符重载：
不能重载的算符
. :: .* ?: sizeof
可以重载的运算符

• • • / % ^ & | ~
      ! = < > += -= = /= %
      ^= &= |= << >> >>= <<= == !=
      <= >= && || ++ – -> ‘ ->
      [] () new delete new[] delete[]
      重载运算符函数可以对运算符作出新的解释，但原有基本语义不变：
      不改变运算符的优先级
      不改变运算符的结合性
      不改变运算符所需要的操作数
      不能创建新的运算符
      成员运算符函数的原型在类的内部声明格式如下:
      class X {
      //…
      返回类型 operator运算符(形参表);
      //…
      }
      在类外定义成员运算符函数的格式如下:
      返回类型 X::operator运算符(形参表)
      {
      函数体
      }
      重载赋值运算符：
      赋值运算符重载用于对象数据的复制
      operator= 必须重载为成员函数
      重载函数原型为：
      类名 & 类名 :: operator= ( 类名 ) ;
      #include
      #include
      using namespace std;
      class Name
      { public :
      Name ( char *pN ) ;
      Name( const Name & ) ; //复制构造函数
      Name& operator=( const Name& ) ; // 重载赋值运算符
      ~ Name() ;
      protected :
      char *pName ;
      int size ;
      } ;
      int main()
      { Name Obj1( “ZhangSan” ) ;
      Name Obj2 = Obj1 ; // 调用复制构造函数
      Name Obj3( “NoName” ) ;
      Obj3 = Obj2 = Obj1 ; // 调用重载赋值运算符函数
      }
      感受：从开学到现在时间也不短了，虽然在家上的课，但是也感受到了课程和作业给的压力。我是转专业过来的，感觉自己底子也是蛮差的，Java数据结构啥的都也没学，做作业有时候还是挺有压力的，有时候感觉自己听明白了但是上不了手，动手能力有点差，不过这样我感觉自己反而能学到的东西更多，就尽力去学吧，在课程和作业中不断提高自己的动手能力，希望自己以后能做的更好！