数组、指针和字符串

刚刚结束了第六章的学习,这里结合一下老师发的ppt和大纲外加教材来小小的自我总结一下

第六章 数组、指针和字符串

 

6.1数组

  •  数组的初始化时,第一维的下标个数可以不用显式说明:

int a[2][3]={1,2,3,4,5,6};

int a[][3]={1,2,3,4,5,6};

  上面两种等价。

  • 数组作为函数参数

 

1 void test(int a[][4],int r){
2        a[0][0]=10;      
3 }
4 int main(){
5        int b[3][4]={1};
6        test(b,3);
7 }

 

  与普通的函数参数不一样,这个时候是传递了数组的地址,所以函数中进行的改变,实际数组的元素也会发生改变

  • 对象数组

  声明和访问形式

类名 数组名[下标表达式];

数组名[下标表达式].成员名

   例如:

 

location a[2]={location(1,2),location(3,4)};
cout
<<a[1].x<<","<<a[1].y;

 


 

 

6.2指针

   指针这里越过基本概念,大概知道指针是通过地址指向目标就行,通过实敲代码来理解最好.

  我把几乎所有知识点都敲到了一个代码里面,下面的各段代码有时候需要结合起来看。

6.2.3 * &

  * 是指针运算符,也是解析 

  &是取地址运算符

6.2.4.1 指针的赋值

 1     int a;
 2     int b[]={99};
 3 /*    int *ptr;
 4     ptr=&a;
 5 */
 6     int *ptr=&a;//这两种定义的效果相同,
 7     //ptr是储存的地址,只有定义的时候可以这样定义,改变的时候要把地址给ptr,值给*ptr 
 8     
 9     int *p=b;//数组名称实际上是一个指针常量,所以可以直接给
10     //这种方式也可以 
11 /*    int *p;    p=b;     */
12 
13     a=10;
14     cout<<"a="<<a<<endl;
15     //*ptr++;//这样得出来的指针所指的值不对,a的值也没有改变 
16     *ptr+=1;//这样以后指针对应的a的值改变了 
17     cout<<"a="<<a<<endl;
18     cout<<"*ptr="<<*ptr<<endl;//输出的是地址上的那个值 
19     cout<<"ptr="<<ptr<<endl;//输出的只是地址 
20     cout<<"*p="<<*p<<endl;
21     cout<<"p="<<p<<endl;

 

6.2.4.2 const相关的指针

    /*
    -----------------------------------------------------------------------------------
    */
    cout<<endl<<"----------常指针知识点:------------"<<""<<endl;
    /*注意区分指向常量的指针 和 指针类型的常量*/ 
    const int *p1=&a;//指向常量的指针,代表地址的p1本身可以改变,而指向的值不能改变 ;弱常指针 
    int *const p2=&a;//指针类型的常量,代表地址的p2本身是常量不能改变,而指向的值依然是变量; 强常指针
    int c=108;
    cout<<"*p1="<<*p1<<"  a="<<a<<endl;
    p1=&c;
    cout<<"*p1="<<*p1<<"  a="<<a<<"   c="<<c<<endl;
/*    *p1=110;    此句话会出错,因为这是指向常量的指针*/
/*    p2=&c;此句话也会出错,这是指针类型的常量,指针本身所指向的地址不能改变,此时地址还是a的地址*/
    cout<<"*p2="<<*p2<<"  a="<<a<<endl;
    *p2=19;
    cout<<"*p2="<<*p2<<"  a="<<a<<endl;

 

6.2.4.3 void类型的指针

 1 /*
 2     -----------------------------------------------------------------------------------
 3     */
 4     cout<<endl<<"----------void类型指针------------"<<""<<endl;
 5     void *pv;//但是可以声明void类型的指针 
 6     //void voidobject  不能声明void类型的变量 
 7     int i=5;
 8     pv=&i;
 9     int *pi=static_cast<int *>(pv);
10     //这是强制转换类型,把void指针转换为int指针赋值给pi 
11     cout<<"*pi="<<*pi<<endl;
12     cout<<" pi="<<pi<<endl;
13     cout<<" pv="<<pv<<endl;//pi pv地址一样,只是指针类型不一样 
14     //cout<<"*pv="<<*pv<<endl;
15     //任何类型的指针都可以赋值给void类型的指针变量
16     //void类型指针一般只在指针指向的数据类型不确定时候使用

 

6.2.5指针运算

 1   /*
 2     -----------------------------------------------------------------------------------
 3     */
 4     cout<<endl<<"----------指针的运算------------"<<""<<endl;    
 5     int *pp;
 6 /*    pp+n; 指针pp后方第n个数的地址 
 7     pp++;指针pp后方第1个数的地址 
 8     pp--; 指针pp前方第1个数的地址 
 9 */
10     //*(pp+1)这是pp指向位置后第一个数的内容
11     //等同于 pp[1]        *(pp-1)  =   pp[-1]
12     //空指针
13     pp=0;
14     pp=NULL; //空指针不指向任何地址
15     /*
16     同类型的指针可以做关系运算 > < >= <= == !=
17     可以与空指针(0 NULL )做关系运算
18     多个关系运算可以构成逻辑运算    
19     */ 
20     int ap[5]={0,1,2,3,4};
21     pp=ap;int *qq=(ap+3);
22     cout<<"qq-pp="<<qq-pp<<endl;//指针做减法运算,qq到pp相隔了三个整型数据 
23     //cout<<"qq+pp="<<qq+pp<<endl;没法做加法运算 
24     cout<<"ap[0]=*pp="<<*pp<<endl;
25     (*pp)++;
26     cout<<"ap[0]=*pp="<<*pp<<endl;
27     
28     ap[1]==*pp++;
29     ap[2]==*(pp++);//*pp++ *(pp++)等效,
30     //因为++后置优先级更高,都是先pp++ ,地址变化,再取指针
31     ap[2]==*qq--;
32     cout<<"pp="<<pp<<"  qq="<<qq<<" (ap+2)=&ap[2]="<<&ap[2]<<endl; 
33     cout<<"*pp="<<*pp<<"  *qq="<<*qq<<" ap[2]="<<ap[2]<<endl; 
34     

 

 

  • 举例子例如定义了*p=&a;

  p只是储存了a的地址,*p才是a所代表的值,p++或者对p进行运算都不能改变a,只是改变*p所指向的值。

  这个地址的运算在数组里面有大用处,因为数组元素的地址是连续的。

  • 空指针的地址是0或者NULL

6.2.6 用指针处理数组元素

 1     /*
 2     -----------------------------------------------------------------------------------
 3     */
 4     cout<<endl<<"----------指针处理数组元素------------"<<""<<endl;     
 5     int array[5]={0,1,2,3,4};
 6     //array == &array[0] == &array  数组名其实就是一个指针变量
 7     //array+3 == &array[3]
 8     *array==array[0];
 9     *(array+1)==array[1]; 
10     for(int *pa=array;pa<(array+5);pa++){
11 //    for(int *pa=&array[0];pa<&array[5];pa++)与上一行等价
12 /*  pa指向了数组每个元素的地址,数组的地址是连续的,
13     所以是小于array【5】的地址,pa++是依次后移一个位置 */ 
14         cout<<*pa<<' ';    
15     }cout<<endl;

 

  • 教材在6.2.4就讲过,数组的名称实际上就是一个不能被赋值的指针,即指针常量,为上文提到的强常指针(不能改变地址,但是可以通过指针改变所指向的值)

  array=&array=&array[0]  数组名这个指针指向了第一个元素(挺重要的,之后运用挺多)

  array+i=&array[i]  数组的运算

6.2.7指针数组

 1     /*
 2     -----------------------------------------------------------------------------------
 3     */
 4     cout<<endl<<"----------指针数组------------"<<""<<endl;
 5     int l1[]={1,0,0};
 6     int l2[]={0,1,0};
 7     int l3[]={0,0,1};
 8     int *ps[3]={l1,l2}; 
 9     ps[2]=l3;
10     cout<<"ps[0]="<<ps[0]<<"  *ps[0]="<<*ps[0]<<endl; 
11     cout<<"l1="<<l1<<"  &l1="<<&l1<<endl;
12     cout<<"ps[0][0]="<<ps[0][0]<<"  l1[0]="<<l1[0]<<endl;
13     cout<<"&ps[0][0]="<<&ps[0][0]<<"  &l1[0]="<<&l1[0]<<endl;
14     //ps[0]=l1=&l1   ps[1]=l2=&l2;
15     cout<<"*(ps[0]+1)="<<*(ps[0]+1)<<" l1[0+1]="<<l1[1]<<endl; 
16     //ps[i][j]  ==  *(ps[i]+j) 
17     int array2[3][3]={{11,12,13},{21,22,23},{31,32,33}};
18     //*(*(array2+i)+j)  ==  array2[i][j] 

 

数组指针并不是很难,

实际就是一个数组,只不过每一个元素都是指针。

语法形式为:

数据类型 *数组名[下标表达式]

只不过要注意区分数组指针和指针数组的概念(此知识点之后补上)

 

6.2.8 用指针作为函数参数

 

1     /*
2     void fun1(int a,int b);
3     void fun2(int *c,int *d);
4     int p,q,e[],f[];
5     fun1(p,q);
6     fun2(&p,&q);
7     fun2(e,f);
8     //fun1不会改变变量本来的值,变的只是形参,fun2的形参是指针,会改变变量。 
9     */ 

 

6.2.9 指针型函数

语法形式

数据类型 *函数名(参数表){
函数体;
}

基本没有深入讲相关知识点,只是提了一下,所以这里也一笔带过

6.2.10 指向函数的指针

 1 void print(double ){
 2     cout<<"A test"<<endl;
 3 }
 4 void write(double data){
 5     cout<<"this test is "<<data<<endl;
 6 }
 7 double message(double data){
 8     return data;
 9 }
10 class node{
11     public:
12         int n,m;
13         node(int n1){
14             n=n1;
15         };
16         void print();
17     private:
18         int b;
19 };
20 void node:: print(){
21     cout<<"6666"<<endl;
22 } 
23 int main(){
24     cout<<endl<<"----------指向函数的指针-----------"<<""<<endl;
25     //数据类型 (*函数指针名)(形参表)
26     //函数指针名=函数名;   函数指针名=&函数名   两种用法相同 
27     void(*pf1)(double);
28     double(*pf2)(double);
29     print(3.14);
30     pf1=&print;
31     pf1(3.14);
32     pf1=&write;
33     pf1(3.14);
34     //pf1=&message;  有错误,这是void类型的函数指针 
35     pf2=message;
36     cout<<pf2(3.14)<<endl;

 

语法形式:

数据类型 (*函数指针名)(形参表)

这里还涉及到了typedef 这个好像在之前章节讲过,还没看,先放这,一会复习前面章节再补上

6.2.11.1对象指针

  感觉和数据指针函数指针这些都大同小异

  用途:多态的实现

  Ps:定义对象的时候会调用类的构造函数,而指针不会。

  可以通过指针来调用对象的成员,不过有特殊形式

对象指针名->成员名

  Or

(*对象指针名).成员名

 

6.2.11.2this 指针

这个指针是直接隐藏于类的每一个非静态成员函数里面的

主要是知识点,教材上也没有实际运用

据说函数形参名称于类的数据成员名称一样,可以用这个区分

大概是

Class node{

       Public:

              Int n;

              Void print(int n){

                     This->n=n;}

}

6.2.11.3指向类的非静态成员指针(指向成员的指针)

       不考这个知识点,暂时空出来以后再说。

 


 

6.3动态内存

 1 class node{
 2     public:
 3         node(){
 4             cout<<"调用了默认构造函数"<<endl; 
 5         }
 6         node(int x,int y){
 7             this->x=x;
 8             this->y=y;
 9             cout<<"调用了构造函数"<<endl;
10         }
11         ~node(){
12             cout<<"调用了析构函数"<<endl; 
13         }
14         void move(int newx,int newy);
15     private:
16         int x,y;
17 };
18 
19 inline void node::move(int newx,int newy){
20     x=newx;y=newy;
21 }
22 
23 int main(){
24     int *p1=new int(6);
25     int *p2=new int();//int *p2=new int;
26     cout<<"p1="<<p1<<" *p1="<<*p1<<endl;
27     delete p1;
28     delete p2;
29     *p1=1;//delete删除了指向的内存空间,指针本身还在 
30     node *pn;
31     pn=new node;
32     delete pn;
33     pn=new node(1,1);
34     delete pn;
35     cout<<"----------申请多个--------"<<endl;
36     //申请多个动态对象数据
37     node *p=new node[2];
38     p[0].move(1,2);
39     p[1].move(3,4); 
40     delete []p;
41     return 0;
42 }

 

 

 

建立和删除堆对象使用运算符 new 和 delete

(在程序里面用了一下this指针,没有出错,真好)

 


 

6.5深复制和浅复制

啊这部分文字好多(巨懒)

咕咕咕

 


 

6.6 字符串

  • string是c++库黎明预定义的类,可以直接使用
  • 字符串是一个字符型的数组,以 \0 结尾
  • 字符串之间的大小比较:字典序
  • 读入:cin getline

  cin读入字符串会以空格 tab制表符 回车作为分隔符

  getline读入一整行,以回车作为分隔符

getline(cin,字符串名);

getline(cin,字符串名,分隔符);   getline(cin,s1,',');

 

  还有gets get cin.get cin.getline getchar scanf等很多读入方式,之后来做个整合。

 


 

#6.4 vector(老师未讲)

定义形式:

vector<元素类型>数组对象名(数组长度);

调用方式和数组一样的 a[i],比较有用的是里面的size

a.size()就是数组a的大小

课本没有讲太多的用法

诸如此类还有 string pair vector map 等,也等以后一同梳理(咕咕咕

 

posted @ 2020-05-08 17:33  Danzel♂  阅读(272)  评论(1编辑  收藏  举报