C++ Primer学习笔记：模板、面向对象编程与操作符重载

5星 · 超过95%的资源需积分: 23 55 浏览量更新于2024-07-25 1 收藏 2.09MB PDF 举报

"这篇学习笔记主要涵盖了C++ Primer一书中的关键概念，包括模板、面向对象编程和重载操作符与转换。笔记作者通过简洁的摘要形式，对书中的核心内容进行了提炼，便于读者快速理解和回顾。" 1. **模板与范型编程** - C++中的模板是一种强大的工具，它允许开发者创建泛化的类和函数，这些类和函数可以在不同的数据类型上工作。模板定义的关键字是`template`，后面跟着`<typename 类型参数>`或`<class 类型参数>`。 - 类型参数通常用T、U等标识符表示，它们代表了未特定的类型，使得模板能够应用于任何数据类型。在实际使用时，模板会被实例化，将类型参数替换为具体的类型。 - 函数模板的定义示例：`template<typename T> 返回类型函数名(模板形参表) { 函数体 }`。这定义了一个接受虚拟类型T的函数模板，调用时会根据传入的实际类型进行实例化。 2. **面向对象编程** - 面向对象编程（OOP）是C++的核心特性，主要包括继承、虚函数和动态绑定。 - **继承**：允许一个类（派生类）继承另一个类（基类）的属性和行为，从而实现代码的复用和扩展。派生类可以添加新的成员，也可以覆盖基类的成员。 - **虚函数**：使用`virtual`关键字声明的函数可以在运行时动态决定调用哪个版本，实现了多态性。虚函数在基类中定义，但在派生类中可以被重写。 - **访问修饰符**：C++提供了`public`、`private`和`protected`三种访问级别。`protected`成员在子类中可访问，但不能直接访问基类的`protected`成员，只能在派生类的成员函数内部访问。 3. **重载操作符与转换** - C++允许用户为自定义类型重载内置操作符，使得类对象能够像内置类型一样进行算术或比较操作。 - 重载操作符的语法是`operator+`等形式，其中`+`代表要重载的操作符。例如，可以重载`+`操作符用于两个类对象的相加。 - 可以重载的运算符包括但不限于加法`+`、减法`-`、乘法`*`、除法`/`、赋值`=`以及比较操作符如`<`、`>`等。 - 重载操作符应确保操作符的行为符合用户的预期，避免产生混淆或误导性的结果。这篇学习笔记是C++初学者的重要参考资料，通过它，读者可以深入理解C++中的模板、面向对象编程和操作符重载等核心概念，为后续的C++学习打下坚实的基础。

b.size()

中所有二进制位个数

b[pos]

访问下标为

pos

位置的位值

b.test(pos)

测试

pos

位置的二进制位是否为

b.set()

将

所有位置

b.set(pos)

将

中

pos

位置的位置

b.reset()

将

所有位置置

b.reset(pos)

将

中

pos

位置的位置

b.flip()

将

中所有位翻转

b.flip(pos)

将

中

pos

位置上的位翻转

b.to_ulong()

将

转化为

unsigned long

值

os<<b

将

的位集合直接输出到

流

注：

b.count

和

b.size()

返回的是

size_t

类型，该类型定义在

cstddef

头文件中（

标准头文件

stddef.h

的

C++

版本）

b[pos]

可以作为左值，即可以用来改变

pos

位置的值

04C++ Primer

第四章

数组与指针

4.1

数组

数组是同一类数据的集合。数组的特点是

以顺序结构结构存储，一点定义就无法更改数组大小。

数组定义很简单：

int a[2] ; //

定义了一个能容纳两个

int

类型数据的数组

const int sz = 2 ;

myclass ls[sz] ;

定义数组的时候系统可能会自动初始化数组的每个项目，但也可以显示提供值。

int a[3]= {1

，

3} ;

可以既指定数组大小又提供初始化列表，此时列表内元素数不能大于维数；

如果列表提供元素小于维数则从数组第一个元素开始显示初始化，没有提供

的数组元素会自动初始化步。

自动初始化遵从下面规则：

对内置类型来说：

int a[2] ; //

表示要自动初始化。如果

是全局定义的则每一项都初始化为

否则会分配随机数，表示未初始化

也可以显示给值例如：

int a[] {1

，

3} ; //

显示初始化时候可以不必提供数组大小，系统会自动推断大小

对于类类型来说：

myclass ls[2] ; //

无论在是全局定义还非全部定义都会调用类型的默认构造函数，如果类没有默认构造函数则编译出错

char

类型数组比较特殊：

char a[]{'a', 'b', 'c'} ; //

标准定义

char b[]{'a', 'b', 'c', '\0'} ; //

一个

风格的字符串，等价于

char b[] = "abc"

二者的字符数组大小都是

上面两种定义方式唯一不同的就是最后一个字符是否是

'\0' (

结束符

)

如果是则表明定义了一个

风格的字符串。

要注意：虽然

char b[] = "abc"

内容只有三个字符，由于这种定义是

风格字符串的定义法所以系统会自动在对应的字符数组后面加上

'\0'

在指定大小定义

风格字符串时要注意前后长度匹配

char b[3] = "abc"

会产生错误，需要存放四个字符大小。

和其他类型定义不同，数组定义是没有类似

int a[](b)

这种定义方式的，因为数组不支持复制操作。

数组最常用的操作办法是小标操作

a[0]

表示第一个项，它是左值操作。

表示数组下标和数组大小的数据类型和

bitset

一样是

size_t

但是数组只有下标操作，没有取大小等其他操作。

size_t sz = 10;

int ls[sz];

for(size_t i = 0; i < sz; if++)

{

cout << ls[i] << endl;

ls[i] = i + 1;

}

4.2

指针的引进

指针一般是对对象的存放地址的直接指向，一般定义形式为

int *cur ; //

定义了一个未初始针未初始化指针值是个随机数

int *cur = 0 ; //

可以给指针赋予初始

值表示该指针没有指向任何对象，不应对其有任何操作

。这个赋值表达式中

值是有约束的，必须是字面常

量或者编译时常量值

int *cur = 121 ; //

也可以给指针赋予一个整数常量，但最好不要这么做。因为该常量表示内存地址而我们并不十分清楚这个地址中存放了什

么数据。一单指针做了某些操作就可能破坏这些数据，对一个未知的内存做指针指向是危险的

(

未初始化指针情况也类似

)

应该在定义是就给予其初始化工作：

int a = 123 ;

int *cur = &a ;

有一类比较灵活的指针

*void

可以指向任何类型的变量；

int a = 123 ;

string b = "abc" ;

void p1 = &a ;

void p2 = &b ;

这类指针表示指向某个内存地址的数据，但不清楚改数据类型。

void

指针操作有限。由于不知道指向的数据类型所以不能对指向数据做任何操

作。

有一类指针可以指向另外的指针

也就是指向指针的指针定义如下：

int a = 123 ;

int *cur = &a ;

int **curr = &cur ;

这类指针需要做两次解引（

**curr

）才能获取真正的对象值。（指向指针的指针，二级指针）

指针操作一般有两个意思：

对指针指向的数据做操作

(

需要解引

int a = 123 ;

int *cur = &a ;

*cur = 456 //

等价于

a = 456;

（对所指向的数据做操作需要做解引在做操作（就是在变量引用时保持

号）

)

对指针本身操作是指改变指针的指向对象

int a = 123 ;

int *cur = &a ;

int b = 123 ;

int *curb = &b ;

a = b ; //

等价于

a = &b (

对指针本身操作不能带解引符号

*) a, b

两个指针现在都指向了变量

，变量

现在没有任何指针指向。

上面讲了数组的基本概念，数组和指针有着非常紧密的联系。

由于数组本身只有下标操作太过简单，所以大部分情况下都使用指针来操作数组。

指针不能直接指向数组变量，它是通过指向数组中得某个项并前后移动来操作数组；

int a[count] = {1,2,3,...} ;

int *cur = a ; //

该操作是简化操作实则是指针指向了数组的第一项，等同于

int *cur = &a[0]

也可以明确指定

int *cur = &a[2] ;

指定了数组的指针可以前后移动，导航到当前项的前后项指针：

int *next = cur +1 ;

int *prv = cur -1 ;

int *next3 = cur +3 ; //

当前项向后移动三位的项指针

数组在数据范围前后一位溢出位的指针表示叫哨兵位，一旦指针到了任意一个哨兵位就不能再做一般化处理。

int a[10] = {1,2,3,...} ;

int *cur = &a[0] ;

int *cur1 = cur -1 ; // cur1

是哨兵位，表示指针已经移出数组

int *cur2 = cur +10 ; // cur1

是哨兵位，表示指针已经移出数组

哨兵位的作用是标识指针已经超出了数组有效范围

两个数组指针可以相减，值是类型为

ptrdiff_t

的项间距（两个操作数中不能有哨兵位）如下：

int a[] = {1,2,3,...} ;

int *cur1 = &a[1] ;

int *cur2 = &a[5] ;

ptrdiff_t pd = cur2 - cur1 ; (

也可以交换两个操作数的位置，结果允许为负数

)

指针可以在数组有效范围内任意移动，找到相应项后如何操作数组的真实值呢？

只需要解引既可。

int a[] = {1,2,3,...} ;

int *cur = &a[1] ;

*cur = 1 ; //

等同于

a[1] = 1

数组最重要的是下标操作。数组指针也有下标操作，但是意义和数组下标不一样

int a[] = {1,2,3,...} ;

int *cur = &a[1] ;

cur[1] = 2 ; //

等价于

*(cur + 2) = 2

也等价于

a[3] = 2

int i = cur[-2] ; //

等价于

int i = *(cur - 2)

也等价于

int i = a[1]

指针是数组的迭代器，最后让让我们看看用指针如何实现迭代

const count = 10;

int arr[count] = {1,2,3...};

for(int *cot = arr; *end = arr + count; cot != end; ++ cot)

{

cout << *cot << endl;

}

可以用

const

修饰定义指针。

指向常量的指针：

const int a = 123 ;

const int *cur =&a ; // const

必须

需要注意：常量的指针必须是指向常量指针，但指向常量指针可以指向常量也可以指向变量。无论如何都不能对它所指内容做更改，即使它实际指向

了变量，但可以更改这个指针的指向

int c =456 ;

cur = &c ; //

更改了指针的指向，现在指向的实际是个变量

*cur = 789 ; //

不允许，虽然指向的是变量但系统认为是常量所以不允许修改

常量指针：

表示不能重新再做指向更改，但也许可以修改它指向的对象的值，这取决于它指向的值是变量还是常量

如下：

const int a = 123 ;

int b = 456 ;

int *const cur1 = &a ; //

此时不允许允许

*cur = 789

，因为指向了一个常量

int *const cur2 = &b ; //

此时允许允许

*cur = 789

，因为指向了一个变量

cur1 = &b ; //

错误，不允许更改指针的指向

需要注意的是这类指针在定义时必须初始化。

如果我定义了这样一个指针

const int *const cur = &a;

那么既不能更改指向的数据值，也不能重新指向其他数据

4.3 c

风格字符串

前面内容了解了

char

数组可以表示

风格字符串，既然数组可以用指针表示那么

char*

也可以表示

风格串

char a[]{'a','b','c','\0'} ; //

第一种数组定义语法

char a[] = “abc” ; //

第

种数组定义语法

char *a = “abc” ; //

指针表示法

风格的字符串有多个操作函数

: strlen(), strcpy(),strcat()

以及

strcmp()

函数中所说的结束标示

NULL

实际上就是最后一个字符

'\0'

。

char s1[10] = {'m','o','b','i','l'};

char s2[20] = {'A','N','S','I','\0','C','+','+'};

char s3[6] = {'I','S','O','C','+','+'};

cout<<strlen(s1)<<endl; // 5

cout<<strlen(s2)<<endl; // 4

cout<<strlen(s3)<<endl; //

不确定

strlen(s1)==5,

原因是

{'m','o','b','i','l'};

指定一部分内容的时候，剩余部分会自动赋值为空字符，而

'\0'

是转义字符表示的就是空字符

strlen(s2)==4

，因为第五个字符是字符串结束符

'\0'

（

==0

）。

strlen(s3)==

？，因为他没有结束符。

可以创建动态数组，动态数组创建时更具类型不同其初始化值也不同。

内置类型

int *a = new int[10] ; //

包含

个未初始化元素的数组

int *b = new int[10]() ; //

包含

个初始化为

的元素数组

类类型

string *c = new string[10] ; //

包含

个调用了类默认构造函数完成初始化的元素数组

可以看到内置类型需要在后面加上

()

才可以让元素初始化。

动态数组定义之后一定要手动删除掉，否则会造成内存泄露

delete [] a ; //

方括号必不可少，表示要释放一个动态数组

剩余79页未读，继续阅读

雷伊_2013

粉丝: 21
资源: 9

C++ Primer学习笔记：模板、面向对象编程与操作符重载

c++primer 学习笔记

C++ Primer学习笔记

C++primer 学习笔记

C++ Primer 学习笔记

C++ primer学习笔记一

C++ Primer学习笔记详解

C++ Primer学习笔记.doc

C++ Primer学习笔记——$11 泛型算法

C++ Primer学习笔记与习题解析

C++ Primer学习笔记与精华摘录

最新资源