【无标题】

p里面存的是地址

*p解地址  查找p中地址的东西
nullptr 是空指针  类似与null
void*只关注指针 不关注指针的大小
可以转化成任意指针 也可以从任意转化成他
void fun(void* param)
{
param +1 会出错
}
int val=42;
int* p=&val;
int** pp=&p;

str复制简单；长度固定；可以复制
vector的底层是arry   vector是容器不是数组

int cookies[5]={1,2,3,4};
cookies =&cookies[1];
表示cookies是第一个元素的地址
当且仅当用于函数头或者函数原型中，int *arr 与int arr[]的意义才相同

void fun(int* param)
{
    param=param+1;
}
int main()
{
    int x=3;
    fun(x);
    x打印出来是3 
}
数组只能覆盖不能删除

c++中二维数组的地址也是连续的

定义一维数组
int a[]={1,2,3,4,5};

int arr[2][3] =
{
    {0,1,2},
    {2,3,5}

}
vector <int>  arry; //定义一个数组 arry


vector< vector<int> > arry; //定义一个数组

vector<int>(n)表示构造一个无名且含n个0的vector<int>对象。

vector<vector <int> > nums(m ,vector<int>(n));    //m*n的二维vector

如果是 vector类行的 可以用 nums.size()来获得长度
如果是二维数组 
获得行数 用nums.size()
获得列数 用nums[0].size()

包含m个vector<int>对象，每个对象都是一个新创立的vector<int>对象的拷贝，而这个新创立的vector<int>对象被初始化为包含n个0。
/*
用来注释一整段话
*/

局部变量在函数内部 全局变量在函数外部


举例子 type 指类型

static 修饰的全局变量不能被其他文件引用

std::cout << "addda"   把这个字符串输出

for 的循环格式

for(int a=10 ;a<20; a++ )  注意是分号
{


}

while 循环
while (a<10)
{

}

break 跳出整个循环语句
continue 跳出本次循环 执行下一次循环

cout << "Element" << setw(13) << "Value" << endl;
Element后边13个空格 其中最后5个被Value填充


计算数组长度 

int arr[] ={4,1,5,6,5};
这种获取长度的方法 nums.length


int length = sizeof(aff) / sizeof(aff[0])
或者
int length = std::end(arr) - std::begin(arr)

如果有return就会退出执行函数


求和
使用 include<numeric>中的accumulate函数
求和时 accumulate(开始地址,结束地址,初值)

int list[10] = { 1,2,3,4,5,6,7,8,9,10 };
int sum= accumulate(list, list+10, 0) ;
nums之前定义了
或者   int total = accumulate(nums.begin(), nums.end(), 0);
求连乘 accumulate(开始地址，结束地址，初值，multiplies<int>())
求string合并    if中有return 则不用else 也行

swap(a,b);  交换a和b  
 #include<algorithm>  头文件

 在for语句中声明的变量 在外部不会存在了

 排序数组用二分位方法查找

除法/ 向下 取的
% 取余数

cin >> x;

<< 输出运算符
>> 输入运算符

一直 输入一个数
while(std::cin >> value)
{   执行语句}
ctrl+z 结束  window
ctrl + D结束  linux

定义变量 尽量赋值

/*
* 左闭右闭  即 [left,right]  目标值在其中  target 可能 = left right
*
*
*/


双指针 用while 相等做fastindex++
不相等做slowIndex = fastIndex


在 C + + 中,用户可以重载函数。这意味着, 只要函数参数的类型不同, 或者参数的 个数不同,或者二者兼而有之, 
两个或者两个以上的函数可以使用相同的函数名。

    int special(int x=5,float y=5.3);
    special(100,79.8);
    special(25); // x=25,y=5.3
    special();//x=5;y=5.3
    int fun(int i, int j = 5 , int k) ;  错误
    int fun(int i, int k, int j = 5) ;


重载函数应在参数个数或参数类型上有所不同, 否则编译程序将无法确定调用 哪一个重载版本,即使返回类型不同, 也不能区分。例如:
int mul(int x, int y) ;
double mul( int x, int y) ;
虽然这两个函数的返回类型不同,但参数个数和类型完全相同, 因此编译程序将无法区分 这两个函数。


作用域运算符“∷”
通常情况下,如果有两个同名变量, 一个是全局的,另一个是局部的, 那么局部变量在 其作用域内具有较高的优先权。

#include < iostream .h > 
int avar = 10; // 全局变量 
int main ( ) { 
	int avar; // 局部变量 
	avar = 25; 
	cout < < ”avar is”< < avar < < endl; 
	return 0; 
}

程序执行结果如下: avar is 25


无名联合   i和f 储存在同一个内存地址中
union 
{
    int i;
    float f;

}

可以直接 i=10;  既不用重新 Int i了；

强制转化类型
将i看成了 函数 
int i =10;
float x=float (i);

引用 需要
int i =5 ;
int &j=i;

j是i的别名， i和j占用内存的同一个位置。当i变化时 j也发生变化

j在定义是 必须赋值 不可以 
int &j;
在 j=i了；

也可以是 
Int i=5;
int &j1 =i;
int &j2 =j1;
引用只能赋值一次；


指针 
int var1;
&var1 表示var1的地址
int *ip;   shengming一个指针

ip =&var1; //在指针变量中储存&var1 的地址

*ip 表示访问地址的值 也就是ip表示地址   *ip表示值


void  swap(int *m , int * n)
 {
   int temp;
   temp = *m;
   *m =*n;
   *n=temp;

 }
int main()
{  int a =5,b=10;  //声明一个a 他的地址是 23244 23244中储存的是5
cout << "a=" << a << "b=" << b << endl;
swap(&a,&b); //将a与b的地址放进去  实际上交换了 a与b的地址
cout << "a=" << a << "b=" << b << endl;
return 0;

}


一个类的成员函数可以不受限制地引
用该类的数据成员,而在该类作用域之外, 
对该 类的数据成员和成员函数的引用则要受到一定的限制, 有时甚至是不允许的。这体现了 类的封装功能。

创建变量 有三步
开辟内存  申明变量 赋初始值
int 帮我干了这三步
but 自己写的类  编译器会把 前两部做了  并不知道怎么赋初始值
通过构造函数 解决

构造函数 没有返回类型  与类的名字一样

析构函数 消灭构造函数时 使用

class 派生类名: 派生方式 基类名{}；
派生方式 可以是 private 或者 public

重载也就是 比如 area在 类 point和 con中都有


union 只能储存一个东西

const 必须初始化


引用 指针会改变实际参数的值



效率较高 
声明为const  tesst(const int &s,const int *d){

}