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++学习笔记——标准库类型vector(1)

一、vector初始化的一些实例  1、vector v1;                   ...

C++ Primer 学习笔记(二)——标准库类型

一、命名空间的using指示与using声明 1、using声明 (1)一个using声明一次只引入一个命名空间成员。 (2)using声明的作用域为:从using声明点开始,直到包含该usin...

C++学习笔记---C++数组和指针

学习C++数组和指针 一维数组与指针 申明了一个一维数组a[10]后,a,&a,&a[0] 都是一样,表示数组的首地址 而申明了一个指针后 p=a;后 p为数组的首地址 而&p为为指针p本身的地...

C++|C++学习笔记|三、数组、字符串、指针

数组、字符串、指针

C++ Primer 学习笔记——第3章:标准库类型 vector

第3章:标准库类型 vector

C++ Primer 学习笔记(4)——标准库string类型

之所以空着笔记三,是因为3的内容要先于4,但似乎课本不是这么认为的。 string对象的定义和初始化 几种方式: string s1; //s1 is empty string s2(s1);...

【C++ Primer学习笔记】第3章:标准库类型

除第2章介绍的基本数据类型外,C++还定义了一个内容丰富的抽象数据类型标准库。 3.1命名空间的using声明 在编译我们提供的实例程序前,读者一定要注意在程序中添加适当的#i...

c++ primer学习笔记3-标准库类型string&vector

1.string 与getline

C++ Primer 学习笔记_6_标准库类型 -- 命名空间using与string类型

 标准库类型(一) --命名空间using与string类型 引:      标准库类型是语言组成部分中更基本的哪些数据类型(如:数组、指针)的抽象! C++标准库定义的是高...

【C++ Primer】【学习笔记】【第三章】标准库类型之:string类型

本章讲解如下三种标准库类型:string、vector、bitset。其中,string定义了大小可变的字符串;vector用于保存一组指定类型的对象;bitset提供了一种抽象方法来操作位的集合。 ...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

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