【C++ Primer】第四章学习笔记 （复合类型）

一，数组
     1，数组只有在定义时候才能使用初始化，不能将一个数组赋给另一个数组。
           int  a[4]={1,2,3,4};//正确
           int  a[4];
           a[4]={1,2,3,4};//不正确
           int  b[4]=a;//不正确
     2，初始化数组时候，提供少于数组元素数目的部分数值，则将剩余赋值为0;
            float   a[5]={1,2};
     3，如果初始化数组时候，方括号内[ ]为空。C++编译器将计算元素个数。
           short   a[ ]={1,2,3,4,5};
           int  number=sizeof(a)/sizeof(short);//计算元素个数（可见字符个数）
           char a[ ]={'a','b','c','d','e'};//必须是char 类型的 字符串
           strlen(a);//计算可见字符串个数
二，字符串
     1，字符串结尾字符为'\0'(ASCII码为0)
            char   a[5]={'a','b','c','d','e'};// 纯字符数组，最好不要当做字符串处理
            char   a[5]={'a','b','c','d','\0'};//结尾为空字符,可以当做字符串处理
            char   a[15]="I am a student";//系统自动在最后一个字符加上'\0';
            char   a[]="I am a student";//系统自动算字符个数
       【remember】确定字符串所需最短数组时候，不要忘记结尾空字符串。
                              "s" 表示两个字符  's'和'\0';
     2，字符串输入:面向行输入getline()
          char a[20]; //必须为char类型的  字符数组
          cin.getline(a,20);//将用户输入的字符 读入到一个包含20个元素的  a数组中。
          cout<<strlen(a);//输出输入字符个数
     如果输入的字符多于19个（1个'\0'），geline仅仅取前19个字符。而多于的不会留在输入队列中（区别与get()）
     3，字符串输入：面向行输入get()
           char a[2];
           char b[2];
           cin.get(a,2);
           cin.get(b,2);
           cout<<strlen(a)<<endl;
           cout<<strlen(b)<<endl;
        输入：abcd
        输出：1   1     如果是getline()则输出：1   0
     get()取的是n-1个可见字符，数组声明为 n 则读取n-1字符，最后一个设置为'\0';遇到换行符则将其留在输入队列。
     第二次调用cin.get()读取第一个字符为  换行符。
     【难点】两个cin 为何只允许输入一次？？  
                        char a[5];
                   cin.get(a,5);
                   cin.get();   //读取输入队列中换行符并丢弃。防止下次读换行符时认为结束而终止。造成第二次不能输入
                   cout<<a[1]<<endl;

                    char b[5];
                    cin.get(b,5);
                    cout<<b[0]<<endl;
三，string类型
        1，连接两个字符串
              string  str1,str2,str3;
              str3=str1+str2;
              /*上面是C++做法，下面是C语言做法*/
              strcpy(str3,str1);//将str1复制到str3中
              strcat(str3,str2);//将str2添加到str1中
         2，未被初始化的字符数组，第一个空字符出现的位置是随机的。
              char a[10];
              cout<<strlen(a);
              输出   4   //0-9  随机
四，结构类型
         1，struct 用法
            struct  node
            {
                    int    data;
                    node   *next;
            }p1;//声明结构类型的变量
          2，共用体  union
            一种数据结构格式存储不同结构类型，但是每次只能使用一个类型。
           struct node
           {
                 int     data;
                 union   id
                {
                         long    id_num;
                         int       id_num;
                }
                 node *next;
             }p1;//

      /*一点了，该睡觉了……未完待续*/
--------------------------------------------------------------------------------------------------------------
     /*元旦三天假期，偷懒了一下。继续奋战*/
          3，枚举   enum
                用法：enum   枚举名{所包含的元素};
                           默认枚举值： enum   name{red,orange,yellow,green,blue}//默认，red=0;orange=1;yellow=2……
                           设置枚举值：enum   name{one=1,two=2,four=4,a,b};//默认指定值  four之后，a=four+1=5;b=6
                 声明变量：name   band;
                                    band=red;//valid     在不进行强制转换情况下，只能将定义枚举时使用的枚举量赋给这种枚举的变量
                                    band++;  //invalid   没有为枚举定义算术运算
                                    band=2;  //invalid    将整型赋值给枚举类型将导致类型错误
                                    int color=2+red// valid   结果为int型，2
                                    band=band(2);//按照{two=2} band=two; 可以通过强制转换的方式 将整型 转化为 枚举类型
           4，指针和自由存储空间
                 1）用法：    int     a=6;
                                 int   *p;//  ‘*p’  表示存储在p地址处的值
                                 p=&a;//指针为p，存储的是值的地址，而不是值本身。
                                或者写为：int*  p=&a;//将指针 p的值设置为;a 而不是将 *p的值
                2）指针的危险
                                long  * length;
                                *length=25365;//length 确实是一个指针，但是没有说明指向哪里，原因是没有初始化指针length
                3） new/delete申请与释放内存
                                int  * pn=new  int ;//分配int型内存，然后把该内存块地址赋值给指针
                                 *pn=100;//给声明的内存单元赋值
                                delete   pn;//释放pn指向的内存单元，不会删除pn指针本身（pn可以指向另一个新分配的内存块）
                              【注意】不要尝试释放已经释放的内存块,delete  pn;之后再delete pn 会有意想不到的错误
                                             不能使用delete释放声明变量所获得的内存（只能释放new申请的）int  *p=&a;//不能delete
                 4）new创建动态数组
                               int  *a=new  int[100];
                               delete  [] a;//[]告诉程序释放的是数组
                              【原则】
                                           不要使用delete释放不是new分配的内存
                                           不要使用delete释放同一个内存块两次
                                           如果使用new[ ]为数组分配内存，则应使用delete[ ]来释放
                                           如果使用new 为变量分配内存，则应使用delete来释放内存，对空指针应用delete是安全的
五，指针、数组和指针算术

         1，double  a[3]={100,200,300};
               double  *p=a;//p指针指向的是数组a的第一个元素的地址
               cout<<"地址为："<<p+1<<"存储的值为："<<*(p+1)<<endl；//输出的是a[1]的地址和a[1]的值
               说明：p+1  增加的量等于 p指针指向类型的字节数（double  8字节）
                           C++将数组名解释为数组第一个元素的地址
        2，sizeof作用于 数组显示数组占用的字节数，作用于指针显示指针长度
              程序：
[html]
        #include "stdio.h"
        int main()
        {
     double a[3]={100.0,200.0,300.0};
     double *p=a;
printf("显示数组占用字节数：%d\n",sizeof(a));//输出24=3*8
printf("显示指针个数：%d\n",sizeof(p));//输出4=3个可见元素加上一个结束符
   }
        3，数组名是第一个元素地址，但是cout对象认为char 数组的地址为字符串地址
              程序：
              
[html]
#include "stdio.h"
#include <iostream>
using namespace std;
int main()
{
    double a[3]={100.0,200.0,300.0};
    char b[5]="rose";
      cout<<"打印double型数组名a:"<<a<<endl;//输出数组第一个元素地址  
    cout<<"打印char型数组名b:"<<b<<endl;//输出字符串  
}
        cout 输出char数组时，从第一个字符元素输出一直到遇到空字符'\0'
       4，不要使用常量和未被初始化的指针来接受输入
             char  *p;
             const  char  *a="rose";
             cin>>p;//不正确
             cin>>a;//不正确
      5，一个使用new和delete的程序范例
[html]
#include "stdio.h"
#include <iostream>
using namespace std;
char *getname();
int main()
{
    char *name;
    name =getname();
    cout<<name<<" at "<<(int *)name <<endl;
    delete []name;
    
    name =getname();
    cout<<name<<" at "<<(int *)name <<endl;
    delete []name;
}
char *getname() //如果要建立大量数组的时候，可以根据要存储变量的大小动态分配内存大小
{
    char temp[80];
    cout<<"Enter last name:";
    cin>>temp;
    char *pn=new char[strlen(temp)+1];
    strcpy(pn,temp);
    return pn;
}
程序说明：两次输出的地址是一样的。如果去掉delete []name 则 已经使用但未被释放的地址无法使用