C++随记

getchar头文件是<stdio.h>
strlen头文件是<cstring>

## 结构体：

struct date *a=&x;
定义结构体变量的指针：
STUDENT stu1;
STUDENT *p;
p=&stu1;
  (or: STUDENT *p=&stu1;)

STUDENT stu1[30];
STUDENT *p;
p=stu1;
   (or: STUDENT *p=stu1;)
   (or: STUDENT *p=&stu1[0];)

## 定义指向成员的指针：

    STUDENT stu1;
    STUDENT *p=&stud1;    //即p=&stud1; *p=stud1;
      stud1.id=011;
      (*p).id=011;
      p->id=011;


枚举类型：



## 引用

：https://www.cnblogs.com/jycboy/p/5184638.html
就是某一变量（目标）的一个别名，对引用的操作与对变量直接操作完全一样。
引用的声明方法：类型标识符 &引用名=目标变量名；
 例：char ch;    char &rp=ch;
 1)引用仅是变量的别名，而不是实实在在地定义了一个变量，
 因此引用本身并不占用内存，
 而是和目标变量共同指向目标变量的内存地址.
 2）表达式中的取地址符&不再是取变量的地址，
 而是用来表示该变量是引用类型的变量。3
 )定义一个引用时，必须对其初始化。
x=(struct node *) malloc(sizeof(struct node))




## 链表：

   p/pr:都是节点 （都包含指针成员变量指向列表中的下一个结点）
   （p！=NULL判断是不是尾节点）
(设单链表表头指针为head，现将指针P指向的结点插入表中，使之成为第一个结点，其操作是: p-> next=head；
head=p;)
(p-> next=head:是把head指向的一个节点赋给了左侧 
不会有东西指向head的  
动他是相当于和他的下一个节点直接联系
只可能是等于他 和她一起指向下一个节点)

x=(struct node *) malloc(sizeof(struct node))    <==> p=new  struct node;
(前者搭配使用：#include<malloc.h>)
sizeof(struct node)
就是求 struct node 这个结构体占用的字节数。
malloc(sizeof(struct node))   
申请 struct node 这个结构体占用字节数大小的空间
(struct node *) malloc(sizeof(struct node))
将申请的空间的地址强制转化为 struct node * 指针类型
x=(struct node *) malloc(sizeof(struct node))
将那个强制转化的地址赋值给 x.*
https://blog.csdn.net/Dr_S_/article/details/78638609


## 字符串输入输出:

 char string1[101],string2[101];
    char *str1=string1,*str2=string2;
    cout<<"有序输入第一串字符串str1:"<<endl;
    cin>>string1;
    cout<<"有序输入第二串字符串str1:"<<endl;
    cin>>string2;
    cout<<str1<<endl;
    cout<<str2<<endl;
    //cout<<string1<<endl;
    //cout<<string2<<endl;

## 排序:

 https://blog.csdn.net/nice__xixi/article/details/81806776
 https://blog.csdn.net/liqinzhe11/article/details/78743743
memset()函数:https://blog.csdn.net/qq_27522735/article/details/53374765
链表合并 1.https://blog.csdn.net/u012301841/article/details/79691580

## 2.

 https://www.cnblogs.com/suixue/p/5824958.html

## 3.

关于：new ListNode(0)什么意思：https://bbs.csdn.net/topics/390806135

## 4.堆对象

：https://baike.baidu.com/item/%E5%A0%86%E5%AF%B9%E8%B1%A1/3347830

## 5.默认构造函数：

https://blog.csdn.net/china_jeffery/article/details/79288103
https://www.cnblogs.com/gklovexixi/p/5814626.html
由不带参数的构造函数，或者为所有的形参提供默认实参的构造函数定义
避免“无参数的默认构造函数”和“带缺省参数的默认构造函数”同时存在

调用重载函数：

## const:

void show()const;后面的const是干什么的?
（不可更改）注意show()必须是一个类的成员函数，后面才可以加上个const；
:https://zhidao.baidu.com/question/132811125.html
ArrayName(const char *pName="noname" );
const:http://www.cnblogs.com/xing901022/p/3413019.html
http://www.cnblogs.com/MakeView660/p/8446155.html
const数据成员 只在某个对象生存期内是常量，而对于整个类而言却是可变的。因为类可以创建多个对象，不同的对象其const数据成员的值可以不同。所以不能在类的声明中初始化const数据成员，因为类的对象没被创建时，编译器不知道const数据成员的值是什么。
const数据成员的初始化只能在类的构造函数的初始化列表中进行。要想建立在整个类中都恒定的常量，应该用类中的枚举常量来实现，或者static cosnt。

## 各种变量：（全局局部寄存器变量等等）:

https://www.cnblogs.com/yc_sunniwell/archive/2010/07/14/1777433.html
（寄存器变量:百度百科）（如果一个变量在程序中频繁使用，例如循环变量，那么，系统就必须多次访问内存中的该单元，影响程序的执行效率。因此，C\C++语言还定义了一种变量，不是保存在内存上，而是直接存储在CPU中的寄存器中，这种变量称为寄存器变量   寄存器变量只能是char、int或指针型   由于register变量使用的是硬件CPU中的寄存器，寄存器变量无地址，所以不能使用取地址运算符"&"求寄存器变量的地址）
 

## 继承的访问控制：

1.public: 能被类成员函数、子类函数、友元访问，也能被类的对象访问。 
private: 只能被类成员函数及友元访问，不能被其他任何访问，本身的类对象也不行。 
protected: 只能被类成员函数、子类函数及友元访问，不能被其他任何访问，本身的类对象也不行。

## 2

.protected继承和private继承能降低访问权限：
使用private继承，父类的protected和public属性在子类中变为private 
使用protected继承，父类的protected和public属性在子类中变为protected 
使用public继承，父类中的protected和public属性不发生改变

## 3.

char *string22=string2; //这里只是数组名 不要带长度
   gets(string1);
   gets(string2);
//cin输入字符串不允许有空格 空格自动判断为下一行
//gets输入数组 这个可以 换行符为下一行


## 预处理命令:

 https://www.cnblogs.com/zi-xing/p/4550246.html
 endif类的解释   https://blog.csdn.net/fly_yr/article/details/39964035


## 引用/常引用:

 如果既要利用引用提高程序的效率，又要保护传递给函数的数据不在函数中被改变，就应使用常引用。
 http://www.cnblogs.com/gw811/archive/2012/10/20/2732687.html
 (引用声明完毕后，相当于目标变量有两个名称即该目标原名称和引用名，且不能再把该引用名作为其他变量名的别名。)

## 常引用：

（一个变量的引用就是变量的别名。实质上，变量名和引用名都指向同一段内存单元。如果形参为变量的引用名，实参为变量名，则在调用函数进行虚实结合时，并不是为形参另外开辟一个存储空间(常称为建立实参的一个拷贝)，而是把实参变量的地址传给形参(引用名)，这样引用名也指向实参变量。
例如：
#include<iostream>
using namespace std;
class Time
{
public:
Time(int,int,int);
int hour;
int minute;
int sec;
};
Time::Time(int h,int m,int s)
{
hour = h;
minute = m;
sec = s;
}
void fun(Time &t) //形参t是Time类对象的引用
{
t.hour = 18;
}
int main()
{
Time t1(10,13,56); //t1是Time类对象
fun(t1); //实参是Time类对象，可以通过引用来修改实参t1的值
cout<<t1.hour<<endl; //输出t1.hour的值为18
return 0;
}
//这里类对象t1里的minute值本来为13，但通过引用修改了实参t1里的值，使其变为

## 18

如果不希望在函数中修改实参t1的值，就可以把引用t声明为const引用(常引用)，函数原型为
void fun(const Time &t);
则在函数中不能改变t的值，也就是不能改变其对应的实参t1的值。
在C++面向对象程序设计中，经常用常指针和常引用作函数参数。这样既能保证数据安全，是数据不能被随意修改，在调用函数时又不必建立实参的拷贝）

 **

## new delete:

**

  new用法:
   2.  开辟数组空间
      一维: int *a = new int[100];开辟一个大小为100的整型数组空间
      二维: int **a = new int[5][6]
      三维及其以上:依此类推.
      一般用法: new 类型 [初值]

 delete用法:
    1. int *a = new int;
              delete a;   //释放单个int的空间
         2.int *a = new int[5];
            delete [] a; //释放int数组空间
  要访问new所开辟的结构体空间,无法直接通过变量名进行,只能通过赋值的指针进行访问.


## 20.

对于int *parray = new int;这个的含义是在系统的堆空间上分配为int，也就是4个字节的空间给parray，这个时候parray里所指的值是没有含义的，如你所说没有定义值。
但是对于Intarray * parray = new Intarray来说，会激发Intarray的构造函数，是否有意义则取决于Intarray的构造函数的内容了。

## delete 指针 删除的是谁的空间

int *p=new int;
delete p;
return 0;
这样就能释放指针指向的内存，而不会释放指针，因此你还可以使用该指针。
（用delete删除指针指向的堆中空间
 用new关键字创建的内存空间不会被系统自动释放，
因此       //可看可不看
1.假如你不去释放，那么该区域的内存始终不能被其他数据所使用。
2.指向该内存的指针是个局部变量，当定义给指针的函数结束并返回时，指针也就消失了，那么就再也找不到该块的内存区域。
假如指向该内存区域的指针自动消失了，计算机就再也找不到该区域的内存了，就好像丢了这块内存一样，这
种情况称为“内存泄漏”。
）


按值传递 (即之前的单向传递)     /按引用传递