C++学习笔记二 C++标准库 数组及指针

原创 2011年01月18日 17:20:00

C++的string跟vector库分别定义了大小可变的字符串和集合。

string跟vector往往将迭代器用作配套类型来访问string中的字符或者vector中的元素。

 

string字符串的size操作的返回值是字符串的长度,类型属于string的配套类型,即string::size_type(是一个unsigned int 或者unsigend long类型)

string类型可以通过下标操作来访问string对象中的单个字符

 

vector类型size操作的返回值是vector集合里元素的个数,类型同理是vector的配套类型vector<T>::size_type (类型同string::size_type)

此处<T>可为int,string 甚至是vector<T>类型分辨表示是一个元素类型为int,string,vector<T>的集合。

vector也可以通过下标操作来访问其中的元素。但是vector下标操作只能用来获取已经存在的元素。

 

vector元素对象还可以使用迭代器来实现。

迭代器是一种支持可用来遍历容器内的元素,并访问这些元素值操作的类型。如数组的迭代器就是指针。

每种容器都定义了自己迭代起的类型,vector的就是vector<T>::iterator

每一种容器也都定义了一队命名为begin()和end()的函数,用于返回迭代器。

如果vector不空 那么他的begin返回的迭代器就是指向第一个元素

end()函数返回的是vector的末端元素的下一个,它不指向容器里的任何一个元素,只表示我们已经处理完所有的元素

迭代器的解引用操作符(*)可以用来访问迭代器所指向的元素

 

 

如:

 

string str("some string");

vector<int> ivec(5);                                                         //定义一个5个元素的vector<int>类型

 

// 利用下标操作符分别输出str字符串中所有字符

for(string::size_type index=0;index!=str.size();++index)

        cout<<str[index]<<endl;

 

//利用下标操作分别输出vector中的各元素值

for(vector<int>::size_type index=0;index!=ivec.size();++index)

      cout<<ivec[index]<<endl;

 

//下标操作可用作左值

//利用下标操作符将str每个字符全部赋值为'a'

for(string::size_type index=0;index!=str.size();++index)

        str[index]='a'; 

 

//vector下标操作只能用于获取已经存在的元素

for(vector<int>::size_type index=0;index!=10;++index)

       ivec[index]=index;                                                         //试图将0-9分别赋值到ivec的第0到第9个元素

                                                                                             //这个是错误的,下标操作只能用于获取已经存在的元素

                                                                                             //此处ivec是只初始化5个元素个数的vector<int>类型

//正确方法应使用push_back();函数

for(vector<int>::size_type index=0;index!=10;++index)

      ivec.push_back(index);                                                   //依次在ivec后面添加新元素

 

//利用迭代器分别输出str字符串中各字符

for(string::iterator iter=str.begin();iter!=str.end();++iter)

        cout<<*iter<<endl;                                               //使用解引用操作符访问迭代器所指向元素的值

 

//利用迭代器分别输出vector中的各元素值

for(vector<int>::iterator iter=ivec.begin();iter!=ivec.end();++iter)

     cout<<*iter<<endl;                                                  //使用解引用操作符访问迭代器所指向元素的值

 

//使用迭代器将str字符串各字符赋值为'a'

for(string::iterator iter=str.begin();iter!=str.end();++iter)

     *iter='a';

 

//使用迭代器赋值容器中的各元素的值

for(vector<int>::iterator iter =ivec.begin();iter!=ivec.end();++iter)

     *iter=0;                                                                     //利用解引用操作符将容器中各元素依次赋值为0

 

iterator类型跟const_iterator

上面使用了iterator来读取或者改写其对应的值

const_iterator只能用来读取对应的值,而不能对其重新赋值

 

 

数组与指针:

数组的定义及初始化

数组的维数必须用值大于等于1的常量表达式定义,此表达式只能包含整型字面值常量(如 5),枚举常量,或者用常量表达式初始化的整型const对象。如:

const unsigned buf_size=512,max_file=20;

int staff_size=127;

const unsigned sz=get_size();                                             //调用get_size()函数获取一个const unsigned类型

char input_buffer[buf_size];                                                 //ok,因为buf_size是一个已经初始化的整型const对象

string fileTable[max_file+1];                                                 //ok,因为max_file也为一个const对象,

                                                                                             //max_file+1在运行的时候已经可以确定他的值

double salaries[staff_size];                                                  //errer staff_size不是一个const对象

int test_scores[get_size()];                                                  //errer get_size()要在程序运行的时候才能计算得它的返回值

int vals[sz];                                                                           //errer 同上

 

初始化

const size_t array_size=3;

//显式初始化

int ia1[array_size]={0,1,2};                                            //如果显式初始化个数小于维数,只初始化前面的数组元素

                                                                                        //剩余的若为内置类型则初始化为0,若是类类型就按默认构造函数初始化

int ia2[]={3,4,5,6}   ;                                                       //不指定维数,按初始化个数来确定数组长度

特殊的字符数组

char ca1[]={'C','+','+'};                                                   //ca1有3个元素

char ca2[]={'C','+','+','/0'};                                             //ca2有4个元素

char ca3[]="C++";                                                          //用字符串字面值初始化字符数组,ca3有4个元素,隐性加一个空字符

char ca4[6]="string";                                                      //错误,因为"string"有7个字符

 

不允许数组直接复制跟赋值。

 

 

数组可以使用下标对每个元素进行操作,数组下标类型为 size_t类型

//利用下标遍历数组中的各个元素,将其下标赋值给各个元素

const size_t array_size=10;

int ia[array_size];

for(size_t index=0;index!=array_size;++index)

        ia[index]=index;

 

同理可以利用下标操作加for循环将一个数组的元素赋值给另外一个同类型同数组

 

指针的定义

c++中使用*符号把一个标识符申明为一个指针

string *pstr;

指针的另一种声明风格

string* pstr;

第二种风格容易使人错以为string*是一种新类型,且在声明多个指针时容易出错。如:

string* ptr1,ptr2;

上句声明了一个字符串指针pstr跟一个字符串ptr2。

使用第一种风格就会很好的避免此类问题

string *ptr1, *ptr2;

 

避免使用未初始化的指针。

如可能的话,除非所指对象已经存在,否则不要先定义指针,这样可以避免一个未初始化的指针。

如果不需分开定义指针跟所指对象,则应将指针初始化成0;

 

指针的操作

指针提供简介操作其指向的对象,跟迭代器一样可以用解引用操作符获取指针所指向的对象。

string s1("hello world");

string s2="abcde";

string *sp=&s1;

cout<<*sp<<end;                         //用解引用操作符获取指针所指向对象的值

解引用操作符返回值可以当左值,用来改变指针所指向的对象的值。

*sp="goodbye";                           //解引用操作符用作左值来修改指针所指向的对象

给指针直接赋值也可以修改指针所指向对象的值,这样不需要使用解引用操作符

sp=&s2;

 

左操作值如果有解引用操作符,修改的是指针指向的对象的值

左操作值中没有解引用操作符,修改的是指针的本身

 

指针跟引用的比较

引用是变量的一个别名,定义引用时必须指定绑定对象,修改引用时同时修改了变量的值

指针是指向一个变量,当修改了指针本身时,并不修改原来指针所指向对象的值

 

使用指针访问数组元素:

C++中的表达式使用数组名,改名字自动转化为指向该数组第一个元素的指针

int ia[]={0,2 ,4 ,6};

int *ip=&ia;   //此时ip指向ia[0]

若要指向到其他元素,使用下标先定位在取地址符获取该元素的地址

ip=&ia[3];     //此时IP指向ia[3]

与其使用下标,使用指针的算术操作更方便。指针加上或者减去一个整型数值n等效获得一个新的指针。

2个指针的减法操作的结果是标准库类型ptrdiff_t的数据.

size_t是unsigend 类型 因为数组的下标不能为负数

ptrdiff_t是signed类型 而指针的减法操作的结果有可能是负数

 

下标跟指针

使用下标访问数组时,实际上是使用下标访问指针

int ia[]={0,2,4,6,8};

int i=ia[0];

int *p=&ia[2];

int j=p[1];     //p[1]=*(p+1),此处p[1]=ia[3]

int k=p[-2];   //p[-2]其实就是*(p-2)等效于ia[0]

 

 

利用指针遍历输出数组元素

const size_t array_size=5;

int ia[array_size]={0,1,2,3,4};

for(int *pbegin=ia,*pend=ia+array_size;pbegin!=pend;++pbegin)

   cout<<*pbegin<<endl;

 

上例中for循环定义了2个int类型的指针pbegin pend

pbegin 指向数组的第一个元素,而pend指向的是数组最后一个元素的下一个(类似vector提供的end()返回的迭代器) 

 

指针跟const限定符

C++强制要求指向const对象的指针也具有const特性

const double *cptr;  //cptr是一个指向double类型的const对象的指针,const限定了cptr指针所指向的对象类型,而非cptr本身

也就是说 cptr本身不是一个const,所以在定义时可以不初始化,后面也可以对其重新赋值,使其指向另一个const对象

但不能通过cptr修改它指向的值,如  *cptr=42;

 

指向const对象的指针理解为“自以为指向const对象的指针”

不能通过指向const对象的指针修改基础对象,然后如果该对象指向的是一个非const对象,可以通过其他方式修改其值 

 

const指针---本身不能修改的指针

int i=0;

int *const ip=&i;  //iph是指向int类型对象的const指针,它的值不能修改,且定义时必须初始化。

 

指向const对象的const指针

const double pi=3.14159;

const double *const pi_ptr=&pi;   //pi是一个指向double类型的const对象的const指针

此时pi_ptr本身不能修改,它指向的对象也不能修改

 

指针跟typedef

typedef string *pstring;

const pstring cstr;

声明const pstring cstr时const修饰的是pstring类型,它是一个指针。

所以cstr定义为一个指向string对象的const指针。等价于string *const cstr;

 

 

 

 

理解复杂的const类型的声明

阅读const类型的声明难易理解是因为const限定符既可以放在类型名前,也可以放在类型名后

const string s1;

string const s2;

s1跟s2都是一个const string类型

用typedef写const类型定义时,const放在类型名前容易对所定义的类型产生误解,

string s1;

typedef string *pstring;

const pstring cstr1=&s1;

pstring const cstr2=&s1;

string *const cstr3=&s1;

把const放在类型pstring之后,然后从右向左阅读该声明语句就会非常清楚的指导cstr2是一个const pstring类型,即指向string类型的const指针。

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

c++的boost库学习笔记

c++的boost库学习 boost和stlport编译,编译过程好麻烦,根据网上教程和boost完全开发指南,加自己摸索才勉强编译完成,做个笔记总结一下,具体编译方法,暂且不写   1,time...
  • u013013970
  • u013013970
  • 2015年04月18日 08:21
  • 1083

C++标准模板库与数据结构的学习

STL(Standard Template Library),即标准模板库,是一个具有工业强度的,高效的C++程序库。它被容纳于C++标准程序库(C++ Standard Library)中,是ANS...
  • sxhelijian
  • sxhelijian
  • 2015年09月20日 08:52
  • 2870

c/c++(疑4) 指针数组和数组指针之间关系

指针数组和数组指针概述(数组指针(指向数组的指针)与指针数组(存放指针的数组)) 指针数组:首先它是一个数组,数组的元素都是指针,数组占多少个字节由数组本身决定。它是“储存指针的数组”的简称。 数...
  • u010236550
  • u010236550
  • 2015年05月08日 11:49
  • 2023

C/C++数组和指针详解

/****************************************************************/ /*            学习是合作和分享式的! /* Au...
  • wdzxl198
  • wdzxl198
  • 2013年06月13日 16:16
  • 7033

C++对象指针数组与堆中对象数组

#include using namespace std; /*堆中对象数组、对象指针数组*/ class stu { public: void set(int x){i = x + 6;} i...
  • u010738823
  • u010738823
  • 2016年05月06日 11:15
  • 1691

C++中new和delete在数组指针和指针数组中的调用

首先,先区分下数组指针和
  • u013025310
  • u013025310
  • 2014年05月14日 23:23
  • 3575

C++ for循环 纯指针遍历多维数组

指针是C/C++中很重要的一个概念,对指针操作熟悉的人,一般对程序对内存的访问和使用都比较敏感,多了解底层是很有益处的。一直都使用下标(subscript)来访问数组。一起来尝试用指针吧 !     ...
  • Ace_Yom
  • Ace_Yom
  • 2015年10月08日 17:54
  • 2396

C++及C中的 string char指针及char数组

推荐第四种:快private static void method4(String src, String des) throws IOException{ // TODO Auto-...
  • uriel_chiang
  • uriel_chiang
  • 2016年08月08日 23:14
  • 464

C++标准库中排序函数sort的用法

(一)为什么要用c++标准库里的排序函数 Sort()函数是c++一种排序方法之一,学会了这种方法也打消我学习c++以来使用的冒泡排序和选择排序所带来的执行效率不高的问题!因为它使用的排序方法是类似于...
  • chandoudeyuyi
  • chandoudeyuyi
  • 2015年06月27日 14:19
  • 4683

【C++】有关c++中数组与指针的关系

下图是代码与运行结果: 1.简单数组与指针的关系(int型数组为例): 解释: 第二句相当于int型指针cp指向了数组的第一个元素,所以,打印出的cp是第一个元素的地址;&cp[0]与...
  • wendongxia
  • wendongxia
  • 2017年02月26日 15:39
  • 833
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:C++学习笔记二 C++标准库 数组及指针
举报原因:
原因补充:

(最多只允许输入30个字)