第4章 数组 数组是由一定数目的同类元素顺序排列而成的结构类型数据 一个数组在内存占有一片连续的存储区域 数组名是存储空间的首地址

Slides:



Advertisements
Similar presentations
1 第二讲 C++ 编程基础. 2 主要内容 C++ 语言概述 C++ 编程基础 数据的简单输入输出 C++ 的发展 C++ 源程序结构与书写规范 C++ 编译器和集成开发环境.
Advertisements

C++语言程序设计教程 第5章 构造数据类型 第6章 C++程序的结构.
第 2 章 初探 C++.
第九讲 类与对象 （I）面向对象基础.
第八章 类和对象.
C++程序设计 王希 图书馆三楼办公室.
Chapter 1 用VC++撰寫程式 Text book: Ivor Horton.
struct 可以在同一個名稱下擁有多種資料型態。使用struct能讓資料的存取和處理更為靈活。
資料大樓 －－談指標與陣列 綠園.
函數(一） 自訂函數、遞迴函數 綠園.
Chap 18 類別與物件 夫有土者，有大物也。有大物者，不可以物。 物而不物，故能物物。 明乎物物者之非物也，豈獨治天下百姓而已哉！
第4章 函数与预处理 4.1 概述 4.2 定义函数的一般形式 4.3 函数参数和函数的值 4.4 函数的调用 *4.5 内置函数
Scope & Lifetime 前言 Local Scope Global Functions & Objects
C++语言程序设计 C++语言程序设计 第六章 指针和引用 第十一组 C++语言程序设计.
刘胥影 东南大学计算机学院 面向对象程序设计1 2011~2012第3学期 刘胥影 东南大学计算机学院.
C++语言程序设计 C++语言程序设计 第四章 数组及自定义数据类型 C++语言程序设计.
第一章 程序的基本结构. 第一章 程序的基本结构 教材及授课结构 本章目标 基本内容 扩展阅读 上机指导 应用举例 习题.
刘胥影 东南大学计算机学院 面向对象程序设计1 2010~2011第3学期 刘胥影 东南大学计算机学院.
C++语言程序设计 C++语言程序设计 第四章 数组及自定义数据类型 C++语言程序设计.
授课老师：龚涛 信息科学与技术学院 2018年3月 教材： 《Visual C++程序员成长攻略》 《C++ Builder程序员成长攻略》
Object-Oriented Programming in C++ 第一章 C++的初步知识
前處理指令可以要求前處理器 (preprocessor) 在程式編譯之前，先進行加入其它檔案的內容、文字取代以及選擇性編譯等工作。
2 C++ 的基本語法和使用環境 親自撰寫和執行程式是學好程式語言的不二法門。本章藉由兩個簡單的程式，介紹C++ 程式的基本結構和開發環境，讓初學者能逐漸建立使用C++ 的信心。
计算机网络讲义 第5章 批量数据处理—数组 一维数组 排序和查找 二维数组 字符串.
6 使用者函數 6.1 函數定義 宣告函數 呼叫函數 呼叫多個函數 6-6
第3讲 C++程序控制结构 3.1 顺序结构 3.2 分支结构 3.3 循环结构 3.4 转向控制 3.5 综合案例分析.
C++程序设计 string（字符串类） vector（容器类）.
C++语言程序设计 第二章 C++简单程序设计.
程序的三种基本结构 if条件分支语句 switch多路开关语句 循环语句 循环嵌套 break，continue和goto语句
C++语言程序设计 第十一章 流类库与输入/输出.
C++语言程序设计 C++语言程序设计 第六章 指针和引用 第十一组 C++语言程序设计.
切換Dev c++顯示語言 工具->環境選項(V)->介面->language (Chinese TW)
C++大学基础教程 第5章 数组 北京科技大学 信息基础科学系.
C++ 程式設計 基礎篇 張啟中 Chang Chi-Chung.
C++大学基础教程 第3章 C++控制语句 北京科技大学 信息基础科学系.
C++大学基础教程 第11章 多态性 北京科技大学 信息基础科学系 2019/4/8 北京科技大学.
Name1..hour //加班時數 name2..hour //請假時數
第二章 基本数据类型及运算 C数据类型概述 基本数据类型 运算符和表达式 混合运算与类型转换 数据的输入输出 顺序程序设计举例.
Chapter 2 & Chapter 3.
C++语言程序设计 C++语言程序设计 第五章 函数 第十一组 C++语言程序设计.
C#程序设计基础 $3 成员、变量和常量.
C++语言程序设计 C++语言程序设计 第七章 类与对象 第十一组 C++语言程序设计.
C++语言程序设计 C++语言程序设计 第七章 类与对象 第十一组 C++语言程序设计.
C++语言程序设计 C++语言程序设计 第九章 类的特殊成员 第十一组 C++语言程序设计.
C++语言程序设计 C++语言程序设计 第三章 控制语句 第十一组 C++语言程序设计.
Oop8 function函式.
C++语言程序设计 C++语言程序设计 第九章 类的特殊成员 第十一组 C++语言程序设计.
物件導向程式設計 CH2.
7.1 C程序的结构 7.2 作用域和作用域规则 7.3 存储属性和生存期 7.4 变量的初始化
第11章 從C到C++語言 11-1 C++語言的基礎 11-2 C++語言的資料型態與運算子 11-3 C++語言的輸出與輸入
C++语言程序设计 C++语言程序设计 第二章 基本数据类型与表达式 第十一组 C++语言程序设计.
C++语言程序设计教程 第2章 数据类型与表达式 第2章 数据类型与表达式 制作人：杨进才 沈显君.
C++语言程序设计 C++语言程序设计 第八章 继承 C++语言程序设计.
<编程达人入门课程> 本节内容 为什么要使用变量? 视频提供：昆山爱达人信息技术有限公司 官网地址： 联系QQ：
C++程式設計入門 變數與運算子 作者：黃建庭.
第二章 类型、对象、运算符和表达式.
第九章 物件導向-進階.
C/C++基礎程式設計班 C++: 物件的使用、參考、重載函式 講師：林業峻 CSIE, NTU 3/28, 2015.
第 3 章 类的基础部分 陈哲 副教授 南京航空航天大学 计算机科学与技术学院.
#include <iostream.h>
C++语言程序设计 C++语言程序设计 第二章 基本数据类型与表达式 第十一组 C++语言程序设计.
C++语言程序设计 第十章 C++标准模板库 成都信息工程学院计算机系.
C++语言程序设计 C++语言程序设计 第十章 多态 第十一组 C++语言程序设计.
C++语言程序设计 C++语言程序设计 第九章 类的特殊成员 第十一组 C++语言程序设计.
《数据结构与算法设计》第一部分 面向对象的C++程序设计基础.
C++语言程序设计 C++语言程序设计 第十一章 异常处理 C++语言程序设计.
變數與資料型態 　綠園.
資料！你家住哪裏？ －－談指標 綠園.
C++语言程序设计 C++语言程序设计 第二章 基本数据类型与表达式 第十一组 C++语言程序设计.
Presentation transcript:

第4章 数组 数组是由一定数目的同类元素顺序排列而成的结构类型数据 一个数组在内存占有一片连续的存储区域 数组名是存储空间的首地址 第4章 数组 数组是由一定数目的同类元素顺序排列而成的结构类型数据 一个数组在内存占有一片连续的存储区域 数组名是存储空间的首地址 数组的每个元素用下标变量标识

第4章 数组 4.1 一维数组 4.2 指针数组 4.3 二维数组 4.4 数组作函数参数 4.5 动态存储 4.6 字符数组与字符串 小结

4.1 一维数组 一维数组的元素是基本类型、结构类型或类类型 一维数组是向量

4.1.1 一维数组与初始化 4.1.1 一维数组定义与初始化 说明格式为： 类型 标识符 [ 表达式 ] ;

4.1.1 一维数组与初始化 4.1.1 一维数组定义与初始化 说明格式为： 类型 标识符 [ 表达式 ] ; 数组元素类型

4.1.1 一维数组与初始化 4.1.1 一维数组定义与初始化 说明格式为： 类型 标识符 [ 表达式 ] ; 数组名 存储地址

4.1.1 一维数组与初始化 4.1.1 一维数组定义与初始化 说明格式为： 类型 标识符 [ 表达式 ] ; 数组元素个数 常整型表达式

4.1.1 一维数组与初始化 4.1.1 一维数组定义与初始化 说明格式为： 类型 标识符 [ 表达式 ] ; 数组的类型

4.1.1 一维数组定义与初始化 例如 const int N = 20 ; const int M = 40 ; 4.1.1 一维数组与初始化 4.1.1 一维数组定义与初始化 例如 const int N = 20 ; const int M = 40 ; const int MaxStringSize = 80 ; const int MaxListSize = 1000 ; int A [ 10 ] ; char B [ MaxStringSize ] ; double C [ M*N ] ; int Values [ MaxListSize ] ; A[0] A[1] A[2] A[3] A[4] A[5] A[6] A[7] A[8] A[9] 数组A C[0] C[1] C[2] C[3] C[4] ： 数组C … B[0] B[1] B[2] : B[11] B[12] B[13] 数组B

4.1.1 一维数组定义与初始化 例： int ary [ 10 ] , i = 3, j = 5 ； 注意 C++ 不提供对数组的 4.1.1 一维数组与初始化 4.1.1 一维数组定义与初始化 注意 C++ 不提供对数组的 下标范围检查 例： int ary [ 10 ] , i = 3, j = 5 ； ary [ 0 ] ary [ 1 ] ary [ 2 ] ary [ 3 ] ary [ 4 ] ary [ 5 ] ary [ 6 ] ary [ 7 ] ary [ 8 ] ary [ 9 ] ary [ 0 ] = 10 10 ary [ ary [ i ] ] = ary [ 0 ] 10 2 ary [ i ] = 2 ary [ j ] = ary [ i ] 2 ary [ 2+j ] = 31 31

4.1.1 一维数组定义与初始化 与普通变量一样，可以在数组定义的同时，对数组元素赋初值 4.1.1 一维数组与初始化 4.1.1 一维数组定义与初始化 与普通变量一样，可以在数组定义的同时，对数组元素赋初值 例： int a [ 5 ] = { 1, 3, 5, 7, 9 }; int b1 [ 5 ] = { 0 } ; int b2 [ 5 ] = { 1, 2, 3, } ; int c [ ] = { 1, 2, 3, 4, 5, 6, 7 } ; int d [ 5 ] = { 1, 2, 3, 4, 5, 6, 7 } ;

4.1.1 一维数组定义与初始化 与普通变量一样，可以在数组定义的同时，对数组元素赋初值 4.1.1 一维数组与初始化 4.1.1 一维数组定义与初始化 与普通变量一样，可以在数组定义的同时，对数组元素赋初值 例： int a [ 5 ] = { 1, 3, 5, 7, 9 }; int b1 [ 5 ] = { 0 } ; int b2 [ 5 ] = { 1, 2, 3, } ; int c [ ] = { 1, 2, 3, 4, 5, 6, 7 } ; int d [ 5 ] = { 1, 2, 3, 4, 5, 6, 7 } ; // 各元素分别赋初始值

4.1.1 一维数组定义与初始化 与普通变量一样，可以在数组定义的同时，对数组元素赋初值 4.1.1 一维数组与初始化 4.1.1 一维数组定义与初始化 与普通变量一样，可以在数组定义的同时，对数组元素赋初值 例： int a [ 5 ] = { 1, 3, 5, 7, 9 }; int b1 [ 5 ] = { 0 } ; int b2 [ 5 ] = { 1, 2, 3, } ; int c [ ] = { 1, 2, 3, 4, 5, 6, 7 } ; int d [ 5 ] = { 1, 2, 3, 4, 5, 6, 7 } ; // 各元素分别赋初始值 // 全部元素初始化为 0

4.1.1 一维数组定义与初始化 与普通变量一样，可以在数组定义的同时，对数组元素赋初值 4.1.1 一维数组与初始化 4.1.1 一维数组定义与初始化 与普通变量一样，可以在数组定义的同时，对数组元素赋初值 例： int a [ 5 ] = { 1, 3, 5, 7, 9 }; int b1 [ 5 ] = { 0 } ; int b2 [ 5 ] = { 1, 2, 3, } ; int c [ ] = { 1, 2, 3, 4, 5, 6, 7 } ; int d [ 5 ] = { 1, 2, 3, 4, 5, 6, 7 } ; // 各元素分别赋初始值 // 全部元素初始化为 0 // b2[3], b2[4]自动赋 0

4.1.1 一维数组定义与初始化 与普通变量一样，可以在数组定义的同时，对数组元素赋初值 4.1.1 一维数组与初始化 4.1.1 一维数组定义与初始化 与普通变量一样，可以在数组定义的同时，对数组元素赋初值 例： int a [ 5 ] = { 1, 3, 5, 7, 9 }; int b1 [ 5 ] = { 0 } ; int b2 [ 5 ] = { 1, 2, 3, } ; int c [ ] = { 1, 2, 3, 4, 5, 6, 7 } ; int d [ 5 ] = { 1, 2, 3, 4, 5, 6, 7 } ; // 各元素分别赋初始值 // 全部元素初始化为 0 // b2[3], b2[4]自动赋 0 // 自动定义数组长度为7

4.1.1 一维数组定义与初始化 与普通变量一样，可以在数组定义的同时，对数组元素赋初值 4.1.1 一维数组与初始化 4.1.1 一维数组定义与初始化 与普通变量一样，可以在数组定义的同时，对数组元素赋初值 例： int a [ 5 ] = { 1, 3, 5, 7, 9 }; int b1 [ 5 ] = { 0 } ; int b2 [ 5 ] = { 1, 2, 3, } ; int c [ ] = { 1, 2, 3, 4, 5, 6, 7 } ; int d [ 5 ] = { 1, 2, 3, 4, 5, 6, 7 } ; // 各元素分别赋初始值 // 全部元素初始化为 0 // b2[3], b2[4]自动赋 0 // 自动定义数组长度为7 // 错误，初始化数据过多

// 例4-1 数组测试 #include<iostream> using namespace std ; int main() 4.1.1 一维数组与初始化 // 例4-1 数组测试 #include<iostream> using namespace std ; int main() { int i , a[ 5 ] = { 1, 3, 5, 7, 9 } ; for ( i = 0; i < 5; i ++ ) cout << a[ i ] << " " ; cout << endl ; static int b[ 5 ] = { 1, 2, 3 }; for ( i = 0 ; i < 5 ; i ++ ) cout << b[ i ] << " " ; int c[ ] = { 1, 2, 3, 4, 5, 6, 7 } ; for ( i = 0 ; i < sizeof ( c ) / sizeof ( int ) ; i ++ ) cout << c[ i ] << " " ; }

// 例4-1 数组测试 #include<iostream> using namespace std ; int main() 4.1.1 一维数组与初始化 // 例4-1 数组测试 #include<iostream> using namespace std ; int main() { int i , a[ 5 ] = { 1, 3, 5, 7, 9 } ; for ( i = 0; i < 5; i ++ ) cout << a[ i ] << " " ; cout << endl ; static int b[ 5 ] = { 1, 2, 3 }; for ( i = 0 ; i < 5 ; i ++ ) cout << b[ i ] << " " ; int c[ ] = { 1, 2, 3, 4, 5, 6, 7 } ; for ( i = 0 ; i < sizeof ( c ) / sizeof ( int ) ; i ++ ) cout << c[ i ] << " " ; } // 声明数组a并初始化

// 例4-1 数组测试 #include<iostream> using namespace std ; int main() 4.1.1 一维数组与初始化 // 例4-1 数组测试 #include<iostream> using namespace std ; int main() { int i , a[ 5 ] = { 1, 3, 5, 7, 9 } ; for ( i = 0; i < 5; i ++ ) cout << a[ i ] << " " ; cout << endl ; static int b[ 5 ] = { 1, 2, 3 }; for ( i = 0 ; i < 5 ; i ++ ) cout << b[ i ] << " " ; int c[ ] = { 1, 2, 3, 4, 5, 6, 7 } ; for ( i = 0 ; i < sizeof ( c ) / sizeof ( int ) ; i ++ ) cout << c[ i ] << " " ; } // 声明数组a并初始化 // 输出数组a的全部元素值

// 例4-1 数组测试 #include<iostream> using namespace std ; int main() 4.1.1 一维数组与初始化 // 例4-1 数组测试 #include<iostream> using namespace std ; int main() { int i , a[ 5 ] = { 1, 3, 5, 7, 9 } ; for ( i = 0; i < 5; i ++ ) cout << a[ i ] << " " ; cout << endl ; static int b[ 5 ] = { 1, 2, 3 }; for ( i = 0 ; i < 5 ; i ++ ) cout << b[ i ] << " " ; int c[ ] = { 1, 2, 3, 4, 5, 6, 7 } ; for ( i = 0 ; i < sizeof ( c ) / sizeof ( int ) ; i ++ ) cout << c[ i ] << " " ; } // 声明数组a并初始化 // 输出数组a的全部元素值 // 声明静态数组b并初始化

// 例4-1 数组测试 #include<iostream> using namespace std ; int main() 4.1.1 一维数组与初始化 // 例4-1 数组测试 #include<iostream> using namespace std ; int main() { int i , a[ 5 ] = { 1, 3, 5, 7, 9 } ; for ( i = 0; i < 5; i ++ ) cout << a[ i ] << " " ; cout << endl ; static int b[ 5 ] = { 1, 2, 3 }; for ( i = 0 ; i < 5 ; i ++ ) cout << b[ i ] << " " ; int c[ ] = { 1, 2, 3, 4, 5, 6, 7 } ; for ( i = 0 ; i < sizeof ( c ) / sizeof ( int ) ; i ++ ) cout << c[ i ] << " " ; } // 声明数组a并初始化 // 输出数组a的全部元素值 // 声明静态数组b并初始化 // 输出数组b的全部元素值

// 例4-1 数组测试 #include<iostream> using namespace std ; int main() 4.1.1 一维数组与初始化 // 例4-1 数组测试 #include<iostream> using namespace std ; int main() { int i , a[ 5 ] = { 1, 3, 5, 7, 9 } ; for ( i = 0; i < 5; i ++ ) cout << a[ i ] << " " ; cout << endl ; static int b[ 5 ] = { 1, 2, 3 }; for ( i = 0 ; i < 5 ; i ++ ) cout << b[ i ] << " " ; int c[ ] = { 1, 2, 3, 4, 5, 6, 7 } ; for ( i = 0 ; i < sizeof ( c ) / sizeof ( int ) ; i ++ ) cout << c[ i ] << " " ; } // 声明数组a并初始化 // 输出数组a的全部元素值 // 声明静态数组b并初始化 // 输出数组b的全部元素值 // 声明数组c，初始化，默认长度 7

// 例4-1 数组测试 #include<iostream> using namespace std ; int main() 4.1.1 一维数组与初始化 // 例4-1 数组测试 #include<iostream> using namespace std ; int main() { int i , a[ 5 ] = { 1, 3, 5, 7, 9 } ; for ( i = 0; i < 5; i ++ ) cout << a[ i ] << " " ; cout << endl ; static int b[ 5 ] = { 1, 2, 3 }; for ( i = 0 ; i < 5 ; i ++ ) cout << b[ i ] << " " ; int c[ ] = { 1, 2, 3, 4, 5, 6, 7 } ; for ( i = 0 ; i < sizeof ( c ) / sizeof ( int ) ; i ++ ) cout << c[ i ] << " " ; } // 声明数组a并初始化 // 输出数组a的全部元素值 int 类型数据字节数 // 声明静态数组b并初始化 // 输出数组b的全部元素值 // 声明数组c，初始化，默认长度 7

// 例4-1 数组测试 #include<iostream> using namespace std ; int main() 4.1.1 一维数组与初始化 // 例4-1 数组测试 #include<iostream> using namespace std ; int main() { int i , a[ 5 ] = { 1, 3, 5, 7, 9 } ; for ( i = 0; i < 5; i ++ ) cout << a[ i ] << " " ; cout << endl ; static int b[ 5 ] = { 1, 2, 3 }; for ( i = 0 ; i < 5 ; i ++ ) cout << b[ i ] << " " ; int c[ ] = { 1, 2, 3, 4, 5, 6, 7 } ; for ( i = 0 ; i < sizeof ( c ) / sizeof ( int ) ; i ++ ) cout << c[ i ] << " " ; } // 声明数组a并初始化 // 输出数组a的全部元素值 数组 c 的字节数 sizeof ( int [7] ) // 声明静态数组b并初始化 // 输出数组b的全部元素值 // 声明数组c，初始化，默认长度 7

// 例4-1 数组测试 #include<iostream> using namespace std ; int main() 4.1.1 一维数组与初始化 // 例4-1 数组测试 #include<iostream> using namespace std ; int main() { int i , a[ 5 ] = { 1, 3, 5, 7, 9 } ; for ( i = 0; i < 5; i ++ ) cout << a[ i ] << " " ; cout << endl ; static int b[ 5 ] = { 1, 2, 3 }; for ( i = 0 ; i < 5 ; i ++ ) cout << b[ i ] << " " ; int c[ ] = { 1, 2, 3, 4, 5, 6, 7 } ; for ( i = 0 ; i < sizeof ( c ) / sizeof ( int ) ; i ++ ) cout << c[ i ] << " " ; } // 声明数组a并初始化 // 输出数组a的全部元素值 数组 c 的元素个数 // 声明静态数组b并初始化 // 输出数组b的全部元素值 // 声明数组c，初始化，默认长度 7

// 例4-1 数组测试 #include<iostream> using namespace std ; int main() 4.1.1 一维数组与初始化 // 例4-1 数组测试 #include<iostream> using namespace std ; int main() { int i , a[ 5 ] = { 1, 3, 5, 7, 9 } ; for ( i = 0; i < 5; i ++ ) cout << a[ i ] << " " ; cout << endl ; static int b[ 5 ] = { 1, 2, 3 }; for ( i = 0 ; i < 5 ; i ++ ) cout << b[ i ] << " " ; int c[ ] = { 1, 2, 3, 4, 5, 6, 7 } ; for ( i = 0 ; i < sizeof ( c ) / sizeof ( int ) ; i ++ ) cout << c[ i ] << " " ; } // 声明数组a并初始化 // 输出数组a的全部元素值 // 声明静态数组b并初始化 // 输出数组b的全部元素值 // 声明数组c，初始化，默认长度 7 // 输出数组c的全部元素值

// 例4-1 数组测试 #include<iostream> using namespace std ; int main() 4.1.1 一维数组与初始化 // 例4-1 数组测试 #include<iostream> using namespace std ; int main() { int i , a[ 5 ] = { 1, 3, 5, 7, 9 } ; for ( i = 0; i < 5; i ++ ) cout << a[ i ] << " " ; cout << endl ; static int b[ 5 ] = { 1, 2, 3 }; for ( i = 0 ; i < 5 ; i ++ ) cout << b[ i ] << " " ; int c[ ] = { 1, 2, 3, 4, 5, 6, 7 } ; for ( i = 0 ; i < sizeof ( c ) / sizeof ( int ) ; i ++ ) cout << c[ i ] << " " ; } // 声明数组a并初始化 // 输出数组a的全部元素值 // 声明静态数组b并初始化 // 输出数组b的全部元素值 // 声明数组c，初始化，默认长度 7 // 输出数组c的全部元素值

4.1.2 一维数组访问 4.1.2 一维数组访问 1．以下标方式访问数组 访问格式： 数组名 [ 表达式 ]

4.1.2 一维数组访问 4.1.2 一维数组访问 1．以下标方式访问数组 访问格式： 数组名 [ 表达式 ] 数组的地址

4.1.2 一维数组访问 4.1.2 一维数组访问 1．以下标方式访问数组 访问格式： 数组名 [ 表达式 ] 整型表达式 地址偏移值

#include<iostream> using namespace std ; int main() 4.1.2 一维数组访问 //例4-2 以下标方式访问数组 #include<iostream> using namespace std ; int main() { int i, total = 0; int intary [10] ; for( i = 0 ; i < 10 ; i ++ ) { intary[ i ] = i ; cout << intary[ i ] << " " ; } cout << endl; for( i = 0; i < 10 ; i ++ ) total += intary[ i ] ; cout << "total = " << total << endl ;

#include<iostream> using namespace std ; int main() 4.1.2 一维数组访问 //例4-2 以下标方式访问数组 #include<iostream> using namespace std ; int main() { int i, total = 0; int intary [10] ; for( i = 0 ; i < 10 ; i ++ ) { intary[ i ] = i ; cout << intary[ i ] << " " ; } cout << endl; for( i = 0; i < 10 ; i ++ ) total += intary[ i ] ; cout << "total = " << total << endl ; 循环控制变量 作下标表达式

4.1.2 一维数组访问 2．以指针方式访问数组 a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7] a[8] 4.1.2 一维数组访问 a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7] a[8] a[9] a 0x0065FDE4 0x0065FDF0 2．以指针方式访问数组 // 例4-3 #include<iostream> using namespace std ; int main() { int a[ 10 ] = { 1, 3, 5, 7, 9 } ; cout << "Address of array a : " << a << endl ; cout << "Address of element a[3] : " << &a[3] << endl ; }

4.1.2 一维数组访问 2．以指针方式访问数组 a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7] a[8] 4.1.2 一维数组访问 a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7] a[8] a[9] a 0x0065FDE4 0x0065FDF0 2．以指针方式访问数组 // 例4-3 #include<iostream> using namespace std ; int main() { int a[ 10 ] = { 1, 3, 5, 7, 9 } ; cout << "Address of array a : " << a << endl ; cout << "Address of element a[3] : " << &a[3] << endl ; } 数组名 是存储空间首地址

4.1.2 一维数组访问 2．以指针方式访问数组 a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7] a[8] 4.1.2 一维数组访问 a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7] a[8] a[9] a 0x0065FDE4 0x0065FDF0 2．以指针方式访问数组 // 例4-3 #include<iostream> using namespace std ; int main() { int a[ 10 ] = { 1, 3, 5, 7, 9 } ; cout << "Address of array a : " << a << endl ; cout << "Address of element a[3] : " << &a[3] << endl ; } 偏移值 3 * sizeof ( int )

4.1.2 一维数组访问 2．以指针方式访问数组 a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7] a[8] 4.1.2 一维数组访问 a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7] a[8] a[9] a 0x0065FDE4 0x0065FDF0 1 3 5 7 9 2．以指针方式访问数组 数组名是隐含意义的常指针（直接地址） 其关联类型是数组元素的类型 int a [ 10 ] = { 1, 3, 5, 7, 9 } ; 则： a == & a [ 0 ] a + 1 == & a [ 1 ] a + i == & a [ i ] *a == a [ 0 ] * ( a + 1 ) == a [ 1 ] * ( a + i ) == a [ i ]

4.1.2 一维数组访问 2．以指针方式访问数组 a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7] a[8] 4.1.2 一维数组访问 a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7] a[8] a[9] 1 3 5 7 9 2．以指针方式访问数组 a 0x0065FDE4 数组名是隐含意义的常指针（直接地址） 其关联类型是数组元素的类型 int a [ 10 ] = { 1, 3, 5, 7, 9 } ; 则： a == & a [ 0 ] a + 1 == & a [ 1 ] a + i == & a [ i ] *a == a [ 0 ] * ( a + 1 ) == a [ 1 ] * ( a + i ) == a [ i ]

4.1.2 一维数组访问 2．以指针方式访问数组 a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7] a[8] 4.1.2 一维数组访问 a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7] a[8] a[9] 1 3 5 7 9 2．以指针方式访问数组 数组名是隐含意义的常指针（直接地址） 其关联类型是数组元素的类型 a+1 0x0065FDE8 int a [ 10 ] = { 1, 3, 5, 7, 9 } ; 则： a == & a [ 0 ] a + 1 == & a [ 1 ] a + i == & a [ i ] *a == a [ 0 ] * ( a + 1 ) == a [ 1 ] * ( a + i ) == a [ i ]

4.1.2 一维数组访问 2．以指针方式访问数组 a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7] a[8] 4.1.2 一维数组访问 a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7] a[8] a[9] 1 3 5 7 9 2．以指针方式访问数组 数组名是隐含意义的常指针（直接地址） 其关联类型是数组元素的类型 int a [ 10 ] = { 1, 3, 5, 7, 9 } ; 则： a+i a+i*sizeof(Type) a == & a [ 0 ] a + 1 == & a [ 1 ] a + i == & a [ i ] *a == a [ 0 ] * ( a + 1 ) == a [ 1 ] * ( a + i ) == a [ i ]

4.1.2 一维数组访问 2．以指针方式访问数组 a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7] a[8] 4.1.2 一维数组访问 a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7] a[8] a[9] 1 3 5 7 9 2．以指针方式访问数组 1 数组名是隐含意义的常指针（直接地址） 其关联类型是数组元素的类型 int a [ 10 ] = { 1, 3, 5, 7, 9 } ; 则： a == & a [ 0 ] a + 1 == & a [ 1 ] a + i == & a [ i ] *a == a [ 0 ] * ( a + 1 ) == a [ 1 ] * ( a + i ) == a [ i ]

4.1.2 一维数组访问 2．以指针方式访问数组 a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7] a[8] 4.1.2 一维数组访问 a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7] a[8] a[9] 1 3 5 7 9 2．以指针方式访问数组 数组名是隐含意义的常指针（直接地址） 其关联类型是数组元素的类型 3 int a [ 10 ] = { 1, 3, 5, 7, 9 } ; 则： a == & a [ 0 ] a + 1 == & a [ 1 ] a + i == & a [ i ] *a == a [ 0 ] * ( a + 1 ) == a [ 1 ] * ( a + i ) == a [ i ]

4.1.2 一维数组访问 2．以指针方式访问数组 a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7] a[8] 4.1.2 一维数组访问 a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7] a[8] a[9] 1 3 5 7 9 2．以指针方式访问数组 数组名是隐含意义的常指针（直接地址） 其关联类型是数组元素的类型 int a [ 10 ] = { 1, 3, 5, 7, 9 } ; 则： 9 a == & a [ 0 ] a + 1 == & a [ 1 ] a + i == & a [ i ] *a == a [ 0 ] * ( a + 1 ) == a [ 1 ] * ( a + i ) == a [ i ]

4.1.2 一维数组访问 2．以指针方式访问数组 a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7] a[8] 4.1.2 一维数组访问 a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7] a[8] a[9] 1 3 5 7 9 2．以指针方式访问数组 数组名是隐含意义的常指针（直接地址） 其关联类型是数组元素的类型 数组元素的 指针访问方式 int a [ 10 ] = { 1, 3, 5, 7, 9 } ; 则： a == & a [ 0 ] a + 1 == & a [ 1 ] a + i == & a [ i ] *a == a [ 0 ] * ( a + 1 ) == a [ 1 ] * ( a + i ) == a [ i ]

#include<iostream> using namespace std ; int main() 4.1.2 一维数组访问 //例4-4 用指针方式访问数组 #include<iostream> using namespace std ; int main() { int i, total = 0; int intary [10] ; for( i = 0 ; i < 10 ; i ++ ) { * ( intary + i ) = i ; cout << * ( intary + i ) << " " ; } cout << endl; for( i = 0; i < 10 ; i ++ ) total += * ( intary + i ) ; cout << "total = " << total << endl ;

#include<iostream> using namespace std ; int main() 4.1.2 一维数组访问 //例4-4 用指针方式访问数组 #include<iostream> using namespace std ; int main() { int i, total = 0; int intary [10] ; for( i = 0 ; i < 10 ; i ++ ) { * ( intary + i ) = i ; cout << * ( intary + i ) << " " ; } cout << endl; for( i = 0; i < 10 ; i ++ ) total += * ( intary + i ) ; cout << "total = " << total << endl ; 数组元素的 指针表示方式

4.1.2 一维数组访问 指针变量与数组 a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7] a[8] a[9] 4.1.2 一维数组访问 a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7] a[8] a[9] a 0x0065FDE4 0x0065FDF0 1 3 5 7 9 指针变量与数组 int a [ 10 ] ; int * p ; p = a ; cout << *p ; p ++ ; cout << *( p++ ) ; p += 3 ; cout << &p ;

4.1.2 一维数组访问 指针变量与数组 a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7] a[8] a[9] 4.1.2 一维数组访问 a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7] a[8] a[9] a 0x0065FDE4 0x0065FDF0 1 3 5 7 9 指针变量与数组 int a [ 10 ] ; int * p ; p = a ; cout << *p ; p ++ ; cout << *( p++ ) ; p += 3 ; cout << &p ; // a 是内存的直接地址

4.1.2 一维数组访问 指针变量与数组 a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7] a[8] a[9] 4.1.2 一维数组访问 a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7] a[8] a[9] a 0x0065FDE4 0x0065FDF0 1 3 5 7 9 指针变量与数组 p int a [ 10 ] ; // a 是内存的直接地址 int * p ; p = a ; cout << *p ; p ++ ; cout << *( p++ ) ; p += 3 ; cout << &p ; // p 是指针变量

4.1.2 一维数组访问 指针变量与数组 a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7] a[8] a[9] 4.1.2 一维数组访问 a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7] a[8] a[9] a 0x0065FDE4 0x0065FDF0 1 3 5 7 9 指针变量与数组 p 0x0065FDE4 int a [ 10 ] ; // a 是内存的直接地址 int * p ; // p 是指针变量 p = a ; cout << *p ; p ++ ; cout << *( p++ ) ; p += 3 ; cout << &p ; // p的值是a[0]的地址

4.1.2 一维数组访问 指针变量与数组 a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7] a[8] a[9] 4.1.2 一维数组访问 a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7] a[8] a[9] a 0x0065FDE4 0x0065FDF0 1 3 5 7 9 指针变量与数组 1 p 0x0065FDE4 int a [ 10 ] ; // a 是内存的直接地址 int * p ; // p 是指针变量 p = a ; // p的值是a[0]的地址 cout << *p ; p ++ ; cout << *( p++ ) ; p += 3 ; cout << &p ; // 间址访问，输出 a[0] 的值

4.1.2 一维数组访问 指针变量与数组 a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7] a[8] a[9] 4.1.2 一维数组访问 a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7] a[8] a[9] a 0x0065FDE4 0x0065FDF0 1 3 5 7 9 指针变量与数组 p 0x0065FDE4 int a [ 10 ] ; // a 是内存的直接地址 int * p ; // p 是指针变量 p = a ; // p的值是a[0]的地址 cout << *p ; // 间址访问，输出 a[0] 的值 p ++ ; cout << *( p++ ) ; p += 3 ; cout << &p ; // p 指向 a[1]

4.1.2 一维数组访问 指针变量与数组 a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7] a[8] a[9] 4.1.2 一维数组访问 a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7] a[8] a[9] a 0x0065FDE4 0x0065FDF0 1 3 5 7 9 指针变量与数组 p 0x0065FDE8 int a [ 10 ] ; // a 是内存的直接地址 int * p ; // p 是指针变量 p = a ; // p的值是a[0]的地址 cout << *p ; // 间址访问，输出 a[0] 的值 p ++ ; // p 指向 a[1] cout << *( p++ ) ; p += 3 ; cout << &p ;

4.1.2 一维数组访问 指针变量与数组 a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7] a[8] a[9] 4.1.2 一维数组访问 a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7] a[8] a[9] a 0x0065FDE4 0x0065FDF0 1 3 5 7 9 指针变量与数组 p 0x0065FDE8 3 int a [ 10 ] ; // a 是内存的直接地址 int * p ; // p 是指针变量 p = a ; // p的值是a[0]的地址 cout << *p ; // 间址访问，输出 a[0] 的值 p ++ ; // p 指向 a[1] cout << *( p++ ) ; p += 3 ; cout << &p ; // 输出 a[1] , p 指向 a[2]

4.1.2 一维数组访问 指针变量与数组 a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7] a[8] a[9] 4.1.2 一维数组访问 a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7] a[8] a[9] a 0x0065FDE4 0x0065FDF0 1 3 5 7 9 指针变量与数组 int a [ 10 ] ; // a 是内存的直接地址 int * p ; // p 是指针变量 p = a ; // p的值是a[0]的地址 cout << *p ; // 间址访问，输出 a[0] 的值 p ++ ; // p 指向 a[1] cout << *( p++ ) ; // 输出 a[1] , p 指向 a[2] p += 3 ; cout << &p ; p 0x0065FDEC

4.1.2 一维数组访问 指针变量与数组 a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7] a[8] a[9] 4.1.2 一维数组访问 a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7] a[8] a[9] a 0x0065FDE4 0x0065FDF0 1 3 5 7 9 指针变量与数组 int a [ 10 ] ; // a 是内存的直接地址 int * p ; // p 是指针变量 p = a ; // p的值是a[0]的地址 cout << *p ; // 间址访问，输出 a[0] 的值 p ++ ; // p 指向 a[1] cout << *( p++ ) ; // 输出 a[1] , p 指向 a[2] p += 3 ; cout << &p ; p 0x0065FDF8 // p 指向 a[5]

4.1.2 一维数组访问 指针变量与数组 a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7] a[8] a[9] 4.1.2 一维数组访问 a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7] a[8] a[9] a 0x0065FDE4 0x0065FDF0 1 3 5 7 9 指针变量与数组 int a [ 10 ] ; // a 是内存的直接地址 int * p ; // p 是指针变量 p = a ; // p的值是a[0]的地址 cout << *p ; // 间址访问，输出 a[0] 的值 p ++ ; // p 指向 a[1] cout << *( p++ ) ; // 输出 a[1] , p 指向 a[2] p += 3 ; cout << &p ; p 0x0065FDF8 指针变量的地址 0x0065FDE0 // p 指向 a[5] // 输出 p 的地址

4.1.2 一维数组访问 指针变量与数组 a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7] a[8] a[9] 4.1.2 一维数组访问 a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7] a[8] a[9] a 0x0065FDE4 0x0065FDF0 1 3 5 7 9 0x0065FDE0 0x0065FDF8 p 指针变量与数组 int a [ 10 ] ; // a 是内存的直接地址 int * p ; // p 是指针变量 p = a ; // p的值是a[0]的地址 cout << *p ; // 间址访问，输出 a[0] 的值 p ++ ; // p 指向 a[1] cout << *( p++ ) ; // 输出 a[1] , p 指向 a[2] p += 3 ; // p 指向 a[5] cout << &p ; // 输出 p 的地址 p 0x0065FDF4

// 例4-5 用指针变量访问数组 1 a[1] 3 a[2] 5 a[3] 7 a[4] 9 4.1.2 一维数组访问 // 例4-5 用指针变量访问数组 #include<iostream> using namespace std ; int main() { int a[] = { 1, 3, 5, 7, 9 } , i , *p ; for( p = a; p < a+5 ; p ++ ) cout << "a[" << p-a << "]=" << *p << '\t'; cout << endl; for( p = a, i = 0 ; i < 5; i ++ ) cout << "a[" << i << "]=" << p[i] << '\t'; cout << endl ; } 1 3 5 7 9 a[0] a[1] a[2] a[3] a[4] a

// 例4-5 用指针变量访问数组 1 a[1] 3 a[2] 5 a[3] 7 a[4] 9 4.1.2 一维数组访问 // 例4-5 用指针变量访问数组 #include<iostream> using namespace std ; int main() { int a[] = { 1, 3, 5, 7, 9 } , i , *p ; for( p = a; p < a+5 ; p ++ ) cout << "a[" << p-a << "]=" << *p << '\t'; cout << endl; for( p = a, i = 0 ; i < 5; i ++ ) cout << "a[" << i << "]=" << p[i] << '\t'; cout << endl ; } 1 3 5 7 9 a[0] a[1] a[2] a[3] a[4] 整型指针 a

// 例4-5 用指针变量访问数组 1 p a[1] 3 a[2] 5 a[3] 7 a[4] 9 4.1.2 一维数组访问 // 例4-5 用指针变量访问数组 #include<iostream> using namespace std ; int main() { int a[] = { 1, 3, 5, 7, 9 } , i , *p ; for( p = a; p < a+5 ; p ++ ) cout << "a[" << p-a << "]=" << *p << '\t'; cout << endl; for( p = a, i = 0 ; i < 5; i ++ ) cout << "a[" << i << "]=" << p[i] << '\t'; cout << endl ; } 1 3 5 7 9 a[0] a[1] a[2] a[3] a[4] p = &a[0] p a

// 例4-5 用指针变量访问数组 1 p a[1] 3 a[2] 5 a[3] 7 a[4] 9 4.1.2 一维数组访问 // 例4-5 用指针变量访问数组 #include<iostream> using namespace std ; int main() { int a[] = { 1, 3, 5, 7, 9 } , i , *p ; for( p = a; p < a+5 ; p ++ ) cout << "a[" << p-a << "]=" << *p << '\t'; cout << endl; for( p = a, i = 0 ; i < 5; i ++ ) cout << "a[" << i << "]=" << p[i] << '\t'; cout << endl ; } 1 3 5 7 9 a[0] a[1] a[2] a[3] a[4] p a 地址偏移 a + 5

// 例4-5 用指针变量访问数组 1 p a[1] 3 a[2] 5 a[3] 7 a[4] 9 4.1.2 一维数组访问 // 例4-5 用指针变量访问数组 #include<iostream> using namespace std ; int main() { int a[] = { 1, 3, 5, 7, 9 } , i , *p ; for( p = a; p < a+5 ; p ++ ) cout << "a[" << p-a << "]=" << *p << '\t'; cout << endl; for( p = a, i = 0 ; i < 5; i ++ ) cout << "a[" << i << "]=" << p[i] << '\t'; cout << endl ; } 1 3 5 7 9 a[0] a[1] a[2] a[3] a[4] p a 间址访问元素 a + 5

// 例4-5 用指针变量访问数组 1 p a[1] 3 a[2] p 5 a[3] 7 a[4] 9 4.1.2 一维数组访问 // 例4-5 用指针变量访问数组 #include<iostream> using namespace std ; int main() { int a[] = { 1, 3, 5, 7, 9 } , i , *p ; for( p = a; p < a+5 ; p ++ ) cout << "a[" << p-a << "]=" << *p << '\t'; cout << endl; for( p = a, i = 0 ; i < 5; i ++ ) cout << "a[" << i << "]=" << p[i] << '\t'; cout << endl ; } 1 3 5 7 9 a[0] a[1] a[2] a[3] a[4] p a 指针移动 p a + 5

// 例4-5 用指针变量访问数组 1 a[1] 3 a[2] p 5 a[3] 7 a[4] 9 4.1.2 一维数组访问 // 例4-5 用指针变量访问数组 #include<iostream> using namespace std ; int main() { int a[] = { 1, 3, 5, 7, 9 } , i , *p ; for( p = a; p < a+5 ; p ++ ) cout << "a[" << p-a << "]=" << *p << '\t'; cout << endl; for( p = a, i = 0 ; i < 5; i ++ ) cout << "a[" << i << "]=" << p[i] << '\t'; cout << endl ; } 1 3 5 7 9 a[0] a[1] a[2] a[3] a[4] a p 下标偏移值 a + 5

// 例4-5 用指针变量访问数组 1 a[1] 3 a[2] p 5 a[3] 7 a[4] 9 4.1.2 一维数组访问 // 例4-5 用指针变量访问数组 #include<iostream> using namespace std ; int main() { int a[] = { 1, 3, 5, 7, 9 } , i , *p ; for( p = a; p < a+5 ; p ++ ) cout << "a[" << p-a << "]=" << *p << '\t'; cout << endl; for( p = a, i = 0 ; i < 5; i ++ ) cout << "a[" << i << "]=" << p[i] << '\t'; cout << endl ; } 1 3 5 7 9 a[0] a[1] a[2] a[3] a[4] a p a + 5

// 例4-5 用指针变量访问数组 注意 循环结束后的指针位置 1 a[1] 3 a[2] 5 a[3] 7 a[4] 9 p 4.1.2 一维数组访问 // 例4-5 用指针变量访问数组 #include<iostream> using namespace std ; int main() { int a[] = { 1, 3, 5, 7, 9 } , i , *p ; for( p = a; p < a+5 ; p ++ ) cout << "a[" << p-a << "]=" << *p << '\t'; cout << endl; for( p = a, i = 0 ; i < 5; i ++ ) cout << "a[" << i << "]=" << p[i] << '\t'; cout << endl ; } 注意 循环结束后的指针位置 1 3 5 7 9 a[0] a[1] a[2] a[3] a[4] a p a + 5 a[0]=1 a[1]=3 a[2]=5 a[3]=7 a[4]=9 a[1]=1 a[3]=3 a[5]=5 a[7]=7 a[9]=9

// 例4-5 用指针变量访问数组 1 a[1] 3 a[2] 5 a[3] 7 a[4] 9 p 4.1.2 一维数组访问 // 例4-5 用指针变量访问数组 #include<iostream> using namespace std ; int main() { int a[] = { 1, 3, 5, 7, 9 } , i , *p ; for( p = a; p < a+5 ; p ++ ) cout << "a[" << p-a << "]=" << *p << '\t'; cout << endl; for( p = a, i = 0 ; i < 5; i ++ ) cout << "a[" << i << "]=" << p[i] << '\t'; cout << endl ; } 1 3 5 7 9 a[0] a[1] a[2] a[3] a[4] a 指针复位 p a + 5 a[0]=1 a[1]=3 a[2]=5 a[3]=7 a[4]=9 a[1]=1 a[3]=3 a[5]=5 a[7]=7 a[9]=9

// 例4-5 用指针变量访问数组 1 p a[1] 3 a[2] 5 a[3] 7 a[4] 9 4.1.2 一维数组访问 // 例4-5 用指针变量访问数组 #include<iostream> using namespace std ; int main() { int a[] = { 1, 3, 5, 7, 9 } , i , *p ; for( p = a; p < a+5 ; p ++ ) cout << "a[" << p-a << "]=" << *p << '\t'; cout << endl; for( p = a, i = 0 ; i < 5; i ++ ) cout << "a[" << i << "]=" << p[i] << '\t'; cout << endl ; } 1 3 5 7 9 a[0] a[1] a[2] a[3] a[4] p a 指针复位 a + 5 a[0]=1 a[1]=3 a[2]=5 a[3]=7 a[4]=9 a[1]=1 a[3]=3 a[5]=5 a[7]=7 a[9]=9

// 例4-5 用指针变量访问数组 1 p a[1] 3 a[2] 5 a[3] 7 a[4] 9 4.1.2 一维数组访问 // 例4-5 用指针变量访问数组 #include<iostream> using namespace std ; int main() { int a[] = { 1, 3, 5, 7, 9 } , i , *p ; for( p = a; p < a+5 ; p ++ ) cout << "a[" << p-a << "]=" << *p << '\t'; cout << endl; for( p = a, i = 0 ; i < 5; i ++ ) cout << "a[" << i << "]=" << p[i] << '\t'; cout << endl ; } 1 3 5 7 9 a[0] a[1] a[2] a[3] a[4] p a 指针变量 下标方式访问元素 a + 5 a[0]=1 a[1]=3 a[2]=5 a[3]=7 a[4]=9 a[1]=1 a[3]=3 a[5]=5 a[7]=7 a[9]=9

// 例4-5 用指针变量访问数组 1 p a[1] 3 a[2] 5 a[3] 7 a[4] 9 4.1.2 一维数组访问 // 例4-5 用指针变量访问数组 #include<iostream> using namespace std ; int main() { int a[] = { 1, 3, 5, 7, 9 } , i , *p ; for( p = a; p < a+5 ; p ++ ) cout << "a[" << p-a << "]=" << *p << '\t'; cout << endl; for( p = a, i = 0 ; i < 5; i ++ ) cout << "a[" << i << "]=" << p[i] << '\t'; cout << endl ; } 1 3 5 7 9 a[0] a[1] a[2] a[3] a[4] p a [ ] 动词 偏置运算，访问对象 a + 5 a[0]=1 a[1]=3 a[2]=5 a[3]=7 a[4]=9 a[1]=1 a[3]=3 a[5]=5 a[7]=7 a[9]=9

// 例4-5 用指针变量访问数组 1 a[1] 3 a[2] 5 a[3] 7 a[4] 9 p 4.1.2 一维数组访问 // 例4-5 用指针变量访问数组 #include<iostream> using namespace std ; int main() { int a[] = { 1, 3, 5, 7, 9 } , i , *p ; for( p = a; p < a+5 ; p ++ ) cout << "a[" << p-a << "]=" << *p << '\t'; cout << endl; for( p = a, i = 0 ; i < 5; i ++ ) cout << "a[" << i << "]=" << p[i] << '\t'; cout << endl ; } 1 3 5 7 9 a[0] a[1] a[2] a[3] a[4] a p a + 5 a[0]=1 a[1]=3 a[2]=5 a[3]=7 a[4]=9

// 例4-5 用指针变量访问数组 1 a[1] 可以吗？ 3 a[2] 5 a[3] 7 a[4] 9 4.1.2 一维数组访问 // 例4-5 用指针变量访问数组 #include<iostream>using namespace std ; int main() { int a[] = { 1, 3, 5, 7, 9 } , i , *p ; for( p = a; p < a+5 ; p ++ ) cout << "a[" << p-a << "]=" << *p << '\t'; cout << endl; for( p = a, i = 0 ; i < 5; i ++ ) cout << "a[" << i << "]=" << p[i] << '\t'; cout << endl ; } 1 3 5 7 9 a[0] a[1] a[2] a[3] a[4] a 可以吗？ for( i = 0; i < 5 ; i ++, a ++ ) cout << "a[" << i << "]=" << *a << '\t'; a + 5

// 例4-5 用指针变量访问数组 1 a[1] 3 a[2] 5 a[3] 7 a[4] 9 4.1.2 一维数组访问 // 例4-5 用指针变量访问数组 #include<iostream> using namespace std ; int main() { int a[] = { 1, 3, 5, 7, 9 } , i , *p ; for( p = a; p < a+5 ; p ++ ) cout << "a[" << p-a << "]=" << *p << '\t'; cout << endl; for( p = a, i = 0 ; i < 5; i ++ ) cout << "a[" << i << "]=" << p[i] << '\t'; cout << endl ; } 1 3 5 7 9 a[0] a[1] a[2] a[3] a[4] a 直接地址 不能修改 for( i = 0; i < 5 ; i ++, a ++ ) cout << "a[" << i << "]=" << *a << '\t'; a + 5

// 例4-5 用指针变量访问数组 讨论指针偏移计算 1 int * p ; a[1] int n ; 3 …… a[2] 5 4.1.2 一维数组访问 // 例4-5 用指针变量访问数组 #include<iostream> using namespace std ; int main() { int a[] = { 1, 3, 5, 7, 9 } , i , *p ; for( p = a; p < a+5 ; p ++ ) cout << "a[" << p-a << "]=" << *p << '\t'; cout << endl; for( p = a, i = 0 ; i < 5; i ++ ) cout << "a[" << i << "]=" << p[i] << '\t'; cout << endl ; } 1 3 5 7 9 a[0] a[1] a[2] a[3] a[4] 讨论指针偏移计算 int * p ; int n ; …… p = p + n ; a 左操作数类型 int * 右操作数类型 int a + 5

// 例4-5 用指针变量访问数组 讨论指针偏移计算 1 int * p ; a[1] int n ; 3 …… a[2] 5 4.1.2 一维数组访问 // 例4-5 用指针变量访问数组 #include<iostream> using namespace std ; int main() { int a[] = { 1, 3, 5, 7, 9 } , i , *p ; for( p = a; p < a+5 ; p ++ ) cout << "a[" << p-a << "]=" << *p << '\t'; cout << endl; for( p = a, i = 0 ; i < 5; i ++ ) cout << "a[" << i << "]=" << p[i] << '\t'; cout << endl ; } 1 3 5 7 9 a[0] a[1] a[2] a[3] a[4] 讨论指针偏移计算 int * p ; int n ; …… p = p + n ; 表达式根据运算相容规则， 依 int* 对n 作类型转换： n*sizeof(int) 字节 a a + 5

// 例4-5 用指针变量访问数组 1 p a[1] 3 a[2] 5 a[3] 7 a[4] 9 4.1.2 一维数组访问 // 例4-5 用指针变量访问数组 #include<iostream> using namespace std ; int main() { int a[] = { 1, 3, 5, 7, 9 } , i , *p ; for( p = a; p < a+5 ; p ++ ) cout << "a[" << p-a << "]=" << *p << '\t'; cout << endl; for( p = a, i = 0 ; i < 5; i ++ ) cout << "a[" << i << "]=" << p[i] << '\t'; cout << endl ; } 1 3 5 7 9 a[0] a[1] a[2] a[3] a[4] p a a + 5

// 例4-5 用指针变量访问数组 1 a[1] 3 a[2] p 5 a[3] 7 a[4] 9 4.1.2 一维数组访问 // 例4-5 用指针变量访问数组 #include<iostream> using namespace std ; int main() { int a[] = { 1, 3, 5, 7, 9 } , i , *p ; for( p = a; p < a+5 ; p ++ ) cout << "a[" << p-a << "]=" << *p << '\t'; cout << endl; for( p = a, i = 0 ; i < 5; i ++ ) cout << "a[" << i << "]=" << p[i] << '\t'; cout << endl ; } 1 3 5 7 9 a[0] a[1] a[2] a[3] a[4] a p a + 5

4.2 指针数组 指针数组的元素类型是指针 指针数组的元素存放对象的地址 说明形式为： 类型 * 标识符 [ 表达式 ] ;

4.2 指针数组 指针数组的元素类型是指针 指针数组的元素存放对象的地址 说明形式为： 类型 * 标识符 [ 表达式 ] ; 数组名

4.2 指针数组 指针数组的元素类型是指针 指针数组的元素存放对象的地址 说明形式为： 类型 * 标识符 [ 表达式 ] ; 数组长度

4.2 指针数组 指针数组的元素类型是指针 指针数组的元素存放对象的地址 说明形式为： 类型 * 标识符 [ 表达式 ] ; 数组元素类型

4.2 指针数组 指针数组的元素类型是指针 指针数组的元素存放对象的地址 说明形式为： 类型 * 标识符 [ 表达式 ] ; 例如： 4.2 指针数组 指针数组的元素类型是指针 指针数组的元素存放对象的地址 说明形式为： 类型 * 标识符 [ 表达式 ] ; 例如： int * pi [ 3 ] ; double * pf [ 5 ] ; char * ps [ 10 ] ;

4.2 指针数组 指针数组的元素类型是指针 指针数组的元素存放对象的地址 说明形式为： 类型 * 标识符 [ 表达式 ] ; 例如： 4.2 指针数组 指针数组的元素类型是指针 指针数组的元素存放对象的地址 说明形式为： 类型 * 标识符 [ 表达式 ] ; 例如： int * pi [ 3 ] ; double * pf [ 5 ] ; char * ps [ 10 ] ; //数组元素是关联类型为整型的指针

4.2 指针数组 指针数组的元素类型是指针 指针数组的元素存放对象的地址 说明形式为： 类型 * 标识符 [ 表达式 ] ; 例如： 4.2 指针数组 指针数组的元素类型是指针 指针数组的元素存放对象的地址 说明形式为： 类型 * 标识符 [ 表达式 ] ; 例如： int * pi [ 3 ] ; double * pf [ 5 ] ; char * ps [ 10 ] ; //数组元素是关联类型为整型的指针 //数组元素是关联类型为浮点型的指针

4.2 指针数组 指针数组的元素类型是指针 指针数组的元素存放对象的地址 说明形式为： 类型 * 标识符 [ 表达式 ] ; 例如： 4.2 指针数组 指针数组的元素类型是指针 指针数组的元素存放对象的地址 说明形式为： 类型 * 标识符 [ 表达式 ] ; 例如： int * pi [ 3 ] ; double * pf [ 5 ] ; char * ps [ 10 ] ; //数组元素是关联类型为整型的指针 //数组元素是关联类型为浮点型的指针 //数组元素是关联类型为字符型的指针

4.2.1 指向基本数据类型的指针数组 // 例4-6 测试指针数组 #include<iostream> 4.2.1 指向基本数据类型的指针数组 4.2 指针数组 // 例4-6 测试指针数组 #include<iostream> using namespace std ; int main() { int a = 11 , b = 22 , c = 33 , * pi [ 3 ] ; pi [ 0 ] = &a ; pi [ 1 ] = &b ; pi [ 2 ] = &c ; for( int i = 0; i < 3 ; i ++ ) cout << *pi [ i ] << " "; }

4.2.1 指向基本数据类型的指针数组 // 例4-6 测试指针数组 #include<iostream> 4.2.1 指向基本数据类型的指针数组 4.2 指针数组 // 例4-6 测试指针数组 #include<iostream> using namespace std ; int main() { int a = 11 , b = 22 , c = 33 , * pi [ 3 ] ; pi [ 0 ] = &a ; pi [ 1 ] = &b ; pi [ 2 ] = &c ; for( int i = 0; i < 3 ; i ++ ) cout << *pi [ i ] << " "; } 33 22 11 a b c pi[0] pi[1] pi[2]

4.2.1 指向基本数据类型的指针数组 // 例4-6 测试指针数组 #include<iostream> 4.2.1 指向基本数据类型的指针数组 4.2 指针数组 // 例4-6 测试指针数组 #include<iostream> using namespace std ; int main() { int a = 11 , b = 22 , c = 33 , * pi [ 3 ] ; pi [ 0 ] = &a ; pi [ 1 ] = &b ; pi [ 2 ] = &c ; for( int i = 0; i < 3 ; i ++ ) cout << *pi [ i ] << " "; } *pi[0] *pi[1] *pi[2] 33 22 11 a b c pi[0] pi[1] pi[2] &a &b &c

4.2.1 指向基本数据类型的指针数组 // 例4-6 测试指针数组 #include<iostream> 4.2.1 指向基本数据类型的指针数组 4.2 指针数组 // 例4-6 测试指针数组 #include<iostream> using namespace std ; int main() { int a = 11 , b = 22 , c = 33 , * pi [ 3 ] ; pi [ 0 ] = &a ; pi [ 1 ] = &b ; pi [ 2 ] = &c ; for( int i = 0; i < 3 ; i ++ ) cout << *pi [ i ] << " "; } *pi[0] *pi[1] *pi[2] 33 22 11 a b c pi[0] pi[1] pi[2] &a &b &c 11 22 33

4.2.2 指向数组的指针数组 // 例4-7 #include<iostream> using namespace std ; 4.2.2 指向数组的指针数组 4.2 指针数组 // 例4-7 #include<iostream> using namespace std ; int main() { double aa [2] = { 1.1, 2.2 } ; double bb [2] = { 3.3, 4.4 } ; double cc [2] = { 5.5, 6.6 } ; double ( * pf [3] ) [2] ; pf [0] = & aa ; pf [1] = & bb ; pf [2] = & cc ; for ( int i = 0 ; i < 3 ; i ++ ) { for ( int j = 0 ; j < 2 ; j ++ ) cout << * ( * pf [ i ] + j ) << " " ; cout << endl ; } pf[0] pf[1] pf[2] &aa &bb &cc aa[0] aa[1] bb[0] bb[1] cc[0] cc[1] 5.5 6.6 3.3 4.4 1.1 2.2 aa bb cc pf

4.2.2 指向数组的指针数组 // 例4-7 #include<iostream> using namespace std ; 4.2.2 指向数组的指针数组 4.2 指针数组 // 例4-7 #include<iostream> using namespace std ; int main() { double aa [2] = { 1.1, 2.2 } ; double bb [2] = { 3.3, 4.4 } ; double cc [2] = { 5.5, 6.6 } ; double ( * pf [3] ) [2] ; pf [0] = & aa ; pf [1] = & bb ; pf [2] = & cc ; for ( int i = 0 ; i < 3 ; i ++ ) { for ( int j = 0 ; j < 2 ; j ++ ) cout << * ( * pf [ i ] + j ) << " " ; cout << endl ; } pf 是长度为3的数组 pf[0] pf[1] pf[2] &aa &bb &cc aa[0] aa[1] bb[0] bb[1] cc[0] cc[1] 5.5 6.6 3.3 4.4 1.1 2.2 aa bb cc pf

4.2.2 指向数组的指针数组 // 例4-7 #include<iostream> using namespace std ; 4.2 指针数组 4.2.2 指向数组的指针数组 // 例4-7 #include<iostream> using namespace std ; int main() { double aa [2] = { 1.1, 2.2 } ; double bb [2] = { 3.3, 4.4 } ; double cc [2] = { 5.5, 6.6 } ; double ( * pf [3] ) [2] ; pf [0] = & aa ; pf [1] = & bb ; pf [2] = & cc ; for ( int i = 0 ; i < 3 ; i ++ ) { for ( int j = 0 ; j < 2 ; j ++ ) cout << * ( * pf [ i ] + j ) << " " ; cout << endl ; } 数组元素是指针 pf[0] pf[1] pf[2] &aa &bb &cc aa[0] aa[1] bb[0] bb[1] cc[0] cc[1] 5.5 6.6 3.3 4.4 1.1 2.2 aa bb cc pf

4.2.2 指向数组的指针数组 // 例4-7 #include<iostream> using namespace std ; 4.2 指针数组 4.2.2 指向数组的指针数组 // 例4-7 #include<iostream> using namespace std ; int main() { double aa [2] = { 1.1, 2.2 } ; double bb [2] = { 3.3, 4.4 } ; double cc [2] = { 5.5, 6.6 } ; double ( * pf [3] ) [2] ; pf [0] = & aa ; pf [1] = & bb ; pf [2] = & cc ; for ( int i = 0 ; i < 3 ; i ++ ) { for ( int j = 0 ; j < 2 ; j ++ ) cout << * ( * pf [ i ] + j ) << " " ; cout << endl ; } 指针的关联类型 是长度为2的浮点数组 double [2] pf[0] pf[1] pf[2] &aa &bb &cc aa[0] aa[1] bb[0] bb[1] cc[0] cc[1] 5.5 6.6 3.3 4.4 1.1 2.2 aa bb cc pf

4.2.2 指向数组的指针数组 // 例4-7 #include<iostream> using namespace std ; 4.2.2 指向数组的指针数组 4.2 指针数组 // 例4-7 #include<iostream> using namespace std ; int main() { double aa [2] = { 1.1, 2.2 } ; double bb [2] = { 3.3, 4.4 } ; double cc [2] = { 5.5, 6.6 } ; double ( * pf [3] ) [2] ; pf [0] = & aa ; pf [1] = & bb ; pf [2] = & cc ; for ( int i = 0 ; i < 3 ; i ++ ) { for ( int j = 0 ; j < 2 ; j ++ ) cout << * ( * pf [ i ] + j ) << " " ; cout << endl ; } 取对象地址 pf[0] pf[1] pf[2] &aa &bb &cc aa[0] aa[1] bb[0] bb[1] cc[0] cc[1] 5.5 6.6 3.3 4.4 1.1 2.2 aa bb cc pf

4.2.2 指向数组的指针数组 // 例4-7 i == 0 , pf [ i ] == &aa 4.2.2 指向数组的指针数组 4.2 指针数组 // 例4-7 #include<iostream> using namespace std ; int main() { double aa [2] = { 1.1, 2.2 } ; double bb [2] = { 3.3, 4.4 } ; double cc [2] = { 5.5, 6.6 } ; double ( * pf [3] ) [2] ; pf [0] = & aa ; pf [1] = & bb ; pf [2] = & cc ; for ( int i = 0 ; i < 3 ; i ++ ) { for ( int j = 0 ; j < 2 ; j ++ ) cout << * ( * pf [ i ] + j ) << " " ; cout << endl ; } i == 0 , pf [ i ] == &aa (1)访问数组元素 pf[0] pf[1] pf[2] &aa &bb &cc aa[0] aa[1] bb[0] bb[1] cc[0] cc[1] 5.5 6.6 3.3 4.4 1.1 2.2 aa bb cc pf

4.2.2 指向数组的指针数组 // 例4-7 i == 0 , pf [ i ] == &aa 4.2.2 指向数组的指针数组 4.2 指针数组 // 例4-7 #include<iostream> using namespace std ; int main() { double aa [2] = { 1.1, 2.2 } ; double bb [2] = { 3.3, 4.4 } ; double cc [2] = { 5.5, 6.6 } ; double ( * pf [3] ) [2] ; pf [0] = & aa ; pf [1] = & bb ; pf [2] = & cc ; for ( int i = 0 ; i < 3 ; i ++ ) { for ( int j = 0 ; j < 2 ; j ++ ) cout << * ( * pf [ i ] + j ) << " " ; cout << endl ; } i == 0 , pf [ i ] == &aa *pf [ i ] == aa (2)访问对象 pf[0] pf[1] pf[2] &aa &bb &cc aa[0] aa[1] bb[0] bb[1] cc[0] cc[1] 5.5 6.6 3.3 4.4 1.1 2.2 aa bb cc pf

4.2.2 指向数组的指针数组 // 例4-7 i == 0 , pf [ i ] == &aa 4.2.2 指向数组的指针数组 4.2 指针数组 // 例4-7 #include<iostream> using namespace std ; int main() { double aa [2] = { 1.1, 2.2 } ; double bb [2] = { 3.3, 4.4 } ; double cc [2] = { 5.5, 6.6 } ; double ( * pf [3] ) [2] ; pf [0] = & aa ; pf [1] = & bb ; pf [2] = & cc ; for ( int i = 0 ; i < 3 ; i ++ ) { for ( int j = 0 ; j < 2 ; j ++ ) cout << * ( * pf [ i ] + j ) << " " ; cout << endl ; } i == 0 , pf [ i ] == &aa *pf [ i ] == aa j ==1 , *pf [ i ]+1 == aa+1 &aa[1] (3)地址偏移 pf[0] pf[1] pf[2] &aa &bb &cc aa[0] aa[1] bb[0] bb[1] cc[0] cc[1] 5.5 6.6 3.3 4.4 1.1 2.2 aa bb cc pf

4.2.2 指向数组的指针数组 // 例4-7 i == 0 , pf [ i ] == &aa 4.2.2 指向数组的指针数组 4.2 指针数组 // 例4-7 #include<iostream> using namespace std ; int main() { double aa [2] = { 1.1, 2.2 } ; double bb [2] = { 3.3, 4.4 } ; double cc [2] = { 5.5, 6.6 } ; double ( * pf [3] ) [2] ; pf [0] = & aa ; pf [1] = & bb ; pf [2] = & cc ; for ( int i = 0 ; i < 3 ; i ++ ) { for ( int j = 0 ; j < 2 ; j ++ ) cout << * ( * pf [ i ] + j ) << " " ; cout << endl ; } i == 0 , pf [ i ] == &aa *pf [ i ] == aa j ==1 , *pf [ i ]+1 == aa+1 *(*pf [ i ]+j) == *(aa+j) == aa[j] (4)访问对象 pf[0] pf[1] pf[2] &aa &bb &cc aa[0] aa[1] bb[0] bb[1] cc[0] cc[1] 5.5 6.6 3.3 4.4 1.1 2.2 aa bb cc pf

4.2.2 指向数组的指针数组 // 例4-7 #include<iostream> using namespace std ; 4.2.2 指向数组的指针数组 4.2 指针数组 // 例4-7 #include<iostream> using namespace std ; int main() { double aa [2] = { 1.1, 2.2 } ; double bb [2] = { 3.3, 4.4 } ; double cc [2] = { 5.5, 6.6 } ; double ( * pf [3] ) [2] ; pf [0] = & aa ; pf [1] = & bb ; pf [2] = & cc ; for ( int i = 0 ; i < 3 ; i ++ ) { for ( int j = 0 ; j < 2 ; j ++ ) cout << * ( * pf [ i ] + j ) << " " ; cout << endl ; } 讨论 aa 与 &aa aa 是一维数组名，内存直接地址 aa 0x0066FDE8 0x0066FDF0 aa[0] aa[1] aa 不是存储在指针变量的值 &aa 没有实质意义

4.2.2 指向数组的指针数组 讨论 aa 与 &aa // 测试aa 与 &aa #include<iostream> 4.2 指针数组 4.2.2 指向数组的指针数组 讨论 aa 与 &aa aa 是一维数组名，内存直接地址 // 测试aa 与 &aa #include<iostream> using namespace std ; int main() { double aa [2] = { 1.1, 2.2 } ; cout << "aa = " << aa <<endl ; cout << "&aa = " << &aa <<endl ; } aa 0x0066FDE8 0x0066FDF0 aa[0] aa[1] aa 不是存储在指针变量的值 &aa 没有实质意义

4.2.2 指向数组的指针数组 // 例4-7 #include<iostream> using namespace std ; 4.2.2 指向数组的指针数组 4.2 指针数组 // 例4-7 #include<iostream> using namespace std ; int main() { double aa [2] = { 1.1, 2.2 } ; double bb [2] = { 3.3, 4.4 } ; double cc [2] = { 5.5, 6.6 } ; double ( * pf [3] ) [2] ; pf [0] = & aa ; pf [1] = & bb ; pf [2] = & cc ; for ( int i = 0 ; i < 3 ; i ++ ) { for ( int j = 0 ; j < 2 ; j ++ ) cout << * ( * pf [ i ] + j ) << " " ; cout << endl ; } 讨论 aa 与 &aa aa 是一维数组名，内存直接地址 二级指针 aa 0x0066FDE8 0x0066FDF0 aa[0] aa[1] aa 不是存储在指针变量的值 &aa 没有实质意义 pf[] 数组元素指向一维数组 元素类型是二级指针 aa 是一级指针 pf [0] = & aa 逻辑上同级指针操作

4.2.2 指向数组的指针数组 // 例4-7 #include<iostream> using namespace std ; 4.2 指针数组 4.2.2 指向数组的指针数组 // 例4-7 #include<iostream> using namespace std ; int main() { double aa [2] = { 1.1, 2.2 } ; double bb [2] = { 3.3, 4.4 } ; double cc [2] = { 5.5, 6.6 } ; double ( * pf [3] ) [2] ; pf [0] = & aa ; pf [1] = & bb ; pf [2] = & cc ; for ( int i = 0 ; i < 3 ; i ++ ) { for ( int j = 0 ; j < 2 ; j ++ ) cout << * ( * pf [ i ] + j ) << " " ; cout << endl ; } 讨论 aa 与 &aa aa 是一维数组名，内存直接地址 修改 aa 0x0066FDE8 0x0066FDF0 aa[0] aa[1] aa 不是存储在指针变量的值 &aa 没有实质意义 pf [0] = aa ; error C2440: '=' : cannot convert from 'double [2]' to 'double (*)[2]' pf[] 数组元素指向一维数组 元素类型是二级指针 aa 是一级指针 pf [0] = & aa 逻辑上同级指针操作

4.2.2 指向数组的指针数组 // 例4-7 #include<iostream> using namespace std ; 4.2.2 指向数组的指针数组 4.2 指针数组 // 例4-7 #include<iostream> using namespace std ; int main() { double aa [2] = { 1.1, 2.2 } ; double bb [2] = { 3.3, 4.4 } ; double cc [2] = { 5.5, 6.6 } ; double ( * pf [3] ) [2] ; pf [0] = & aa ; pf [1] = & bb ; pf [2] = & cc ; for ( int i = 0 ; i < 3 ; i ++ ) { for ( int j = 0 ; j < 2 ; j ++ ) cout << * ( * pf [ i ] + j ) << " " ; cout << endl ; } 讨论 aa 与 &aa aa 是一维数组名，内存直接地址 一级指针 aa 0x0066FDE8 0x0066FDF0 aa[0] aa[1] aa 不是存储在指针变量的值 &aa 没有实质意义 pf [0] = aa ; error C2440: '=' : cannot convert from 'double [2]' to 'double (*)[2]' pf[] 数组元素指向一维数组 元素类型是二级指针 aa 是一级指针 pf [0] = & aa 逻辑上同级指针操作

4.2.2 指向数组的指针数组 // 例4-7 #include<iostream> using namespace std ; 4.2.2 指向数组的指针数组 4.2 指针数组 // 例4-7 #include<iostream> using namespace std ; int main() { double aa [2] = { 1.1, 2.2 } ; double bb [2] = { 3.3, 4.4 } ; double cc [2] = { 5.5, 6.6 } ; double ( * pf [3] ) [2] ; pf [0] = & aa ; pf [1] = & bb ; pf [2] = & cc ; for ( int i = 0 ; i < 3 ; i ++ ) { for ( int j = 0 ; j < 2 ; j ++ ) cout << * ( * pf [ i ] + j ) << " " ; cout << endl ; } 讨论 aa 与 &aa aa 是一维数组名，内存直接地址 二级指针 aa 0x0066FDE8 0x0066FDF0 aa[0] aa[1] aa 不是存储在指针变量的值 &aa 没有实质意义 pf [0] = aa ; error C2440: '=' : cannot convert from 'double [2]' to 'double (*)[2]' pf[] 数组元素指向一维数组 元素类型是二级指针 aa 是一级指针 pf [0] = & aa 逻辑上同级指针操作

4.2.2 指向数组的指针数组 // 例4-7 #include<iostream> using namespace std ; 4.2.2 指向数组的指针数组 4.2 指针数组 // 例4-7 #include<iostream> using namespace std ; int main() { double aa [2] = { 1.1, 2.2 } ; double bb [2] = { 3.3, 4.4 } ; double cc [2] = { 5.5, 6.6 } ; double ( * pf [3] ) [2] ; pf [0] = & aa ; pf [1] = & bb ; pf [2] = & cc ; for ( int i = 0 ; i < 3 ; i ++ ) { for ( int j = 0 ; j < 2 ; j ++ ) cout << * ( * pf [ i ] + j ) << " " ; cout << endl ; } 定义数组类型 double [2] typedef double aryType [2] ; aryType aa = { 1.1, 2.2 } ; aryType bb = { 3.3, 4.4 } ; aryType cc = { 5.5, 6.6 } ; aryType * pf [ 3 ] ; pf[0] pf[1] pf[2] &aa &bb &cc aa[0] aa[1] bb[0] bb[1] cc[0] cc[1] 5.5 6.6 3.3 4.4 1.1 2.2 aa bb cc pf

4.2.3 指向函数的指针数组 // 例4-8 用指针数组调用函数 // func.h #ifndef FUNC_H 4.2.3 指向函数的指针数组 4.2 指针数组 // 例4-8 用指针数组调用函数 // func.h #ifndef FUNC_H #define FUNC_H const double PI = 3.1415; double Square_Girth ( double l ) { return 4 * l ; } double Square_Area ( double l ) { return l * l ; } double Round_Girth ( double r ) { return 2 * PI * r ; } double Round_Area ( double r ) { return PI * r * r ; } typedef double ft ( double ) ; #endif //ex4_8.cpp #include<iostream> using namespace std ; #include " func.h " int main() { int i ; double x = 1.23 ; ft * pfun [ 4 ] ; pfun [ 0 ] = Square_Girth ; pfun [ 1 ] = Square_Area ; pfun [ 2 ] = Round_Girth ; pfun [ 3 ] = Round_Area ; for ( i = 0 ; i < 4 ; i ++ ) cout << ( * pfun [ i ] ) ( x ) << endl ; }

4.2.3 指向函数的指针数组 // 例4-8 用指针数组调用函数 // func.h #ifndef FUNC_H 4.2.3 指向函数的指针数组 4.2 指针数组 // 例4-8 用指针数组调用函数 // func.h #ifndef FUNC_H #define FUNC_H const double PI = 3.1415; double Square_Girth ( double l ) { return 4 * l ; } double Square_Area ( double l ) { return l * l ; } double Round_Girth ( double r ) { return 2 * PI * r ; } double Round_Area ( double r ) { return PI * r * r ; } typedef double ft ( double ) ; #endif //ex4_8.cpp #include<iostream> using namespace std ; #include " func.h " int main() { int i ; double x = 1.23 ; ft * pfun [ 4 ] ; pfun [ 0 ] = Square_Girth ; pfun [ 1 ] = Square_Area ; pfun [ 2 ] = Round_Girth ; pfun [ 3 ] = Round_Area ; for ( i = 0 ; i < 4 ; i ++ ) cout << ( * pfun [ i ] ) ( x ) << endl ; }

4.2.3 指向函数的指针数组 // 例4-8 用指针数组调用函数 // func.h #ifndef FUNC_H 4.2 指针数组 4.2.3 指向函数的指针数组 // 例4-8 用指针数组调用函数 // func.h #ifndef FUNC_H #define FUNC_H const double PI = 3.1415; double Square_Girth ( double l ) { return 4 * l ; } double Square_Area ( double l ) { return l * l ; } double Round_Girth ( double r ) { return 2 * PI * r ; } double Round_Area ( double r ) { return PI * r * r ; } typedef double ft ( double ) ; #endif //ex4_8.cpp #include<iostream> using namespace std ; #include " func.h " int main() { int i ; double x = 1.23 ; ft * pfun [ 4 ] ; pfun [ 0 ] = Square_Girth ; pfun [ 1 ] = Square_Area ; pfun [ 2 ] = Round_Girth ; pfun [ 3 ] = Round_Area ; for ( i = 0 ; i < 4 ; i ++ ) cout << ( * pfun [ i ] ) ( x ) << endl ; } 函数类型

4.2.3 指向函数的指针数组 //ex4_8.cpp #include<iostream> 4.2.3 指向函数的指针数组 4.2 指针数组 // 例4-8 用指针数组调用函数 // func.h #ifndef FUNC_H #define FUNC_H const double PI = 3.1415; double Square_Girth ( double l ) { return 4 * l ; } double Square_Area ( double l ) { return l * l ; } double Round_Girth ( double r ) { return 2 * PI * r ; } double Round_Area ( double r ) { return PI * r * r ; } typedef double ft ( double ) ; #endif //ex4_8.cpp #include<iostream> using namespace std ; #include " func.h " int main() { int i ; double x = 1.23 ; ft * pfun [ 4 ] ; pfun [ 0 ] = Square_Girth ; pfun [ 1 ] = Square_Area ; pfun [ 2 ] = Round_Girth ; pfun [ 3 ] = Round_Area ; for ( i = 0 ; i < 4 ; i ++ ) cout << ( * pfun [ i ] ) ( x ) << endl ; } //ex4_8.cpp #include<iostream>using namespace std ; #include " func.h " int main() { int i ; double x = 1.23 ; ft * pfun [ 4 ] ; pfun [ 0 ] = Square_Girth ; pfun [ 1 ] = Square_Area ; pfun [ 2 ] = Round_Girth ; pfun [ 3 ] = Round_Area ; for ( i = 0 ; i < 4 ; i ++ ) cout << ( * pfun [ i ] ) ( x ) << endl ; return ; }

4.2.3 指向函数的指针数组 //ex4_8.cpp #include<iostream> 声明指向函数的 4.2.3 指向函数的指针数组 4.2 指针数组 // 例4-8 用指针数组调用函数 // func.h #ifndef FUNC_H #define FUNC_H const double PI = 3.1415; double Square_Girth ( double l ) { return 4 * l ; } double Square_Area ( double l ) { return l * l ; } double Round_Girth ( double r ) { return 2 * PI * r ; } double Round_Area ( double r ) { return PI * r * r ; } typedef double ft ( double ) ; #endif //ex4_8.cpp #include<iostream> using namespace std ; #include " func.h " int main() { int i ; double x = 1.23 ; ft * pfun [ 4 ] ; pfun [ 0 ] = Square_Girth ; pfun [ 1 ] = Square_Area ; pfun [ 2 ] = Round_Girth ; pfun [ 3 ] = Round_Area ; for ( i = 0 ; i < 4 ; i ++ ) cout << ( * pfun [ i ] ) ( x ) << endl ; } 声明指向函数的 指针数组 //ex4_8.cpp #include<iostream>using namespace std ; #include " func.h " int main() { int i ; double x = 1.23 ; ft * pfun [ 4 ] ; pfun [ 0 ] = Square_Girth ; pfun [ 1 ] = Square_Area ; pfun [ 2 ] = Round_Girth ; pfun [ 3 ] = Round_Area ; for ( i = 0 ; i < 4 ; i ++ ) cout << ( * pfun [ i ] ) ( x ) << endl ; return ; }

4.2.3 指向函数的指针数组 //ex4_8.cpp #include<iostream> 4.2.3 指向函数的指针数组 4.2 指针数组 // 例4-8 用指针数组调用函数 // func.h #ifndef FUNC_H #define FUNC_H const double PI = 3.1415; double Square_Girth ( double l ) { return 4 * l ; } double Square_Area ( double l ) { return l * l ; } double Round_Girth ( double r ) { return 2 * PI * r ; } double Round_Area ( double r ) { return PI * r * r ; } typedef double ft ( double ) ; #endif //ex4_8.cpp #include<iostream> using namespace std ; #include " func.h " int main() { int i ; double x = 1.23 ; ft * pfun [ 4 ] ; pfun [ 0 ] = Square_Girth ; pfun [ 1 ] = Square_Area ; pfun [ 2 ] = Round_Girth ; pfun [ 3 ] = Round_Area ; for ( i = 0 ; i < 4 ; i ++ ) cout << ( * pfun [ i ] ) ( x ) << endl ; } 获取 函数入口地址 //ex4_8.cpp #include<iostream>using namespace std ; #include " func.h " int main() { int i ; double x = 1.23 ; ft * pfun [ 4 ] ; pfun [ 0 ] = Square_Girth ; pfun [ 1 ] = Square_Area ; pfun [ 2 ] = Round_Girth ; pfun [ 3 ] = Round_Area ; for ( i = 0 ; i < 4 ; i ++ ) cout << ( * pfun [ i ] ) ( x ) << endl ; return ; }

4.2.3 指向函数的指针数组 //ex4_8.cpp #include<iostream> 4.2.3 指向函数的指针数组 4.2 指针数组 // 例4-8 用指针数组调用函数 // func.h #ifndef FUNC_H #define FUNC_H const double PI = 3.1415; double Square_Girth ( double l ) { return 4 * l ; } double Square_Area ( double l ) { return l * l ; } double Round_Girth ( double r ) { return 2 * PI * r ; } double Round_Area ( double r ) { return PI * r * r ; } typedef double ft ( double ) ; #endif //ex4_8.cpp #include<iostream> using namespace std ; #include " func.h " int main() { int i ; double x = 1.23 ; ft * pfun [ 4 ] ; pfun [ 0 ] = Square_Girth ; pfun [ 1 ] = Square_Area ; pfun [ 2 ] = Round_Girth ; pfun [ 3 ] = Round_Area ; for ( i = 0 ; i < 4 ; i ++ ) cout << ( * pfun [ i ] ) ( x ) << endl ; } //ex4_8.cpp #include<iostream>using namespace std ; #include " func.h " int main() { int i ; double x = 1.23 ; ft * pfun [ 4 ] ; pfun [ 0 ] = Square_Girth ; pfun [ 1 ] = Square_Area ; pfun [ 2 ] = Round_Girth ; pfun [ 3 ] = Round_Area ; for ( i = 0 ; i < 4 ; i ++ ) cout << ( * pfun [ i ] ) ( x ) << endl ; return ; } 调用 不同函数

4.2.3 指向函数的指针数组 //ex4_8.cpp #include<iostream> 4.2.3 指向函数的指针数组 4.2 指针数组 // 例4-8 用指针数组调用函数 // func.h #ifndef FUNC_H #define FUNC_H const double PI = 3.1415; double Square_Girth ( double l ) { return 4 * l ; } double Square_Area ( double l ) { return l * l ; } double Round_Girth ( double r ) { return 2 * PI * r ; } double Round_Area ( double r ) { return PI * r * r ; } typedef double ft ( double ) ; #endif //ex4_8.cpp #include<iostream> using namespace std ; #include " func.h " int main() { int i ; double x = 1.23 ; ft * pfun [ 4 ] ; pfun [ 0 ] = Square_Girth ; pfun [ 1 ] = Square_Area ; pfun [ 2 ] = Round_Girth ; pfun [ 3 ] = Round_Area ; for ( i = 0 ; i < 4 ; i ++ ) cout << ( * pfun [ i ] ) ( x ) << endl ; } //ex4_8.cpp #include<iostream>using namespace std ; #include " func.h " int main() { int i ; double x = 1.23 ; ft * pfun [ 4 ] ; pfun [ 0 ] = Square_Girth ; pfun [ 1 ] = Square_Area ; pfun [ 2 ] = Round_Girth ; pfun [ 3 ] = Round_Area ; for ( i = 0 ; i < 4 ; i ++ ) cout << ( * pfun [ i ] ) ( x ) << endl ; return ; } 等价 调用方式 ( pfun [ i ] ) ( x )

× 4.2.3 指向函数的指针数组 //ex4_8.cpp #include<iostream> 4.2.3 指向函数的指针数组 4.2 指针数组 // 例4-8 用指针数组调用函数 // func.h #ifndef FUNC_H #define FUNC_H const double PI = 3.1415; double Square_Girth ( double l ) { return 4 * l ; } double Square_Area ( double l ) { return l * l ; } double Round_Girth ( double r ) { return 2 * PI * r ; } double Round_Area ( double r ) { return PI * r * r ; } typedef double ft ( double ) ; #endif //ex4_8.cpp #include<iostream> using namespace std ; #include " func.h " int main() { int i ; double x = 1.23 ; ft * pfun [ 4 ] ; pfun [ 0 ] = Square_Girth ; pfun [ 1 ] = Square_Area ; pfun [ 2 ] = Round_Girth ; pfun [ 3 ] = Round_Area ; for ( i = 0 ; i < 4 ; i ++ ) cout << ( * pfun [ i ] ) ( x ) << endl ; } //ex4_8.cpp #include<iostream>using namespace std ; #include " func.h " int main() { int i ; double x = 1.23 ; ft * pfun [ 4 ] ; pfun [ 0 ] = Square_Girth ; pfun [ 1 ] = Square_Area ; pfun [ 2 ] = Round_Girth ; pfun [ 3 ] = Round_Area ; for ( i = 0 ; i < 4 ; i ++ ) cout << ( * pfun [ i ] ) ( x ) << endl ; return ; } 指针变量地址 不是函数地址 × (&pfun [ i ] ) ( x )

4.3 二维数组 二维数组 每一个元素是类型相同、长度相等的一维数组 n 维数组 每一个元素是类型相同、长度相等的 n-1 维数组

4.3 二维数组 二维数组 a [ 0 ] a [ 1 ] a [ 2 ] 17 19 20 18 23 16 22 19 25 23 16 31

4.3 二维数组 二维数组 a [ 0 ] a [ 1 ] a [ 2 ] a[0][0] a[0][1] a[0][2] a[0][3]

4.3 二维数组 三维数组 17 19 10 18 23 26 22 29 25 23 28 21 37 39 30 38 43 46 42 49 55 43 36 31 b [ 0 ] b [ 1 ] b [ 2 ]

4.3 二维数组 三维数组 b[0][0] 17 19 10 18 b [ 0 ] b[0][1] 23 26 22 29 b[1][0] 17 19 10 18 23 26 22 29 25 23 28 21 37 39 30 38 43 46 42 49 55 43 36 31 b [ 0 ] b [ 1 ] b [ 2 ]

4.3 二维数组 三维数组 b [ 0 ] b [ 1 ] b [ 2 ] b[0][0] b[0][1] b[1][0] b[1][1] b[2][0] b[2][1] b[0][0][0] b[0][0][1] b[0][0][2] b[0][0][3] b[0][0][4] b[0][1][0] b[0][1][1] b[0][1][2] b[0][1][3] b[0][1][4] b[1][0][0] b[1][0][1] b[1][0][2] b[1][0][3] b[1][0][4] b[1][1][0] b[1][1][1] b[1][1][2] b[1][1][3] b[1][1][4] b[2][0][0] b[2][0][1] b[2][0][2] b[2][0][3] b[2][0][4] b[2][1][0] b[2][1][1] b[2][1][2] b[2][1][3] b[2][1][4]

4.3.1 二维数组定义与初始化 定义多维数组 类型 数组名 [ 常量表达式 ] … [ 常量表达式 ] ; 例： 类型 数组名 [ 常量表达式 ] … [ 常量表达式 ] ; 例： int a [ 3 ] [ 4 ] ; // 二维数组，3 行4列 double b [ 2 ] [ 3 ] [ 2 ] ; // 三维数组，2  3  2 = 12 个元素 int i [ 2 ] [ 3 ] = { { 1, 2, 3 }, { 4, 5, 6 } } ; // 数组初始化 int j [ 2 ] [ 3 ] = { 1, 2, 3, 4, 5, 6 } ; // 与 i 数组初始化方式等价 int k [ ] [ 2 ] [ 3 ] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 } ; // 缺省第一维长度 int l [ ] [ 4 ] = { { 1 }, { 1 }, { 1 } } ; // 仅对第 0 列元素赋初值 int m [ 3 ] [ ] = { 1, 2, 3, 4, 5, 6 } // 错误，不能省略第二维长度

多维数组按高维优先存放 a [ 3 ] [ 4 ] b [ 2 ] [ 3 ] [ 2 ] a [ 0 ] [ 0 ] 4.3.1 二维数组定义与初始化 多维数组按高维优先存放 a [ 3 ] [ 4 ] b [ 2 ] [ 3 ] [ 2 ] a [ 0 ] [ 0 ] a [ 0 ] [ 1 ] a [ 0 ] [ 2 ] a [ 0 ] [ 3 ] b [ 0 ] [ 0 ] [ 0 ] b [ 0 ] [ 0 ] [ 1 ] b [ 0 ] [ 1 ] [ 0 ] b [ 0 ] [ 1 ] [ 1 ] a [ 1 ] [ 0 ] a [ 1 ] [ 1 ] a [ 1 ] [ 2 ] a [ 1 ] [ 3 ] b [ 0 ] [ 2 ] [ 0 ] b [ 0 ] [ 2 ] [ 1 ] b [ 1 ] [ 0 ] [ 0 ] b [ 1 ] [ 0 ] [ 1 ] a [ 2 ] [ 0 ] a [ 2 ] [ 1 ] a [ 2 ] [ 2 ] a [ 2 ] [ 3 ] b [ 1 ] [ 1 ] [ 0 ] b [ 1 ] [ 1 ] [ 1 ] b [ 1 ] [ 2 ] [ 0 ] b [ 1 ] [ 2 ] [ 1 ]

4.3.2 二维数组访问 4.3.2 二维数组访问 1. 以下标方式访问二维数组 数组名 [ 表达式1 ] [ 表达式2 ]

// 例4-9 访问二维数组 #include <iostream> #include <iomanip> 4.3.2 二维数组访问 // 例4-9 访问二维数组 #include <iostream> #include <iomanip> using namespace std ; int main ( ) { int a [ 3 ] [ 4 ] ; int i , j ; for ( i = 0 ; i < 3 ; i ++ ) for ( j = 0 ; j < 4 ; j ++ ) cin >> a [ i ] [ j ] ; { for ( j = 0 ; j < 4 ; j ++ ) cout << setw ( 5 ) << a [ i ] [ j ] ; cout << endl ; }

// 例4-9 访问二维数组 a #include <iostream> #include <iomanip> 4.3.2 二维数组访问 // 例4-9 访问二维数组 #include <iostream> #include <iomanip> using namespace std ; int main ( ) { int a [ 3 ] [ 4 ] ; int i , j ; for ( i = 0 ; i < 3 ; i ++ ) for ( j = 0 ; j < 4 ; j ++ ) cin >> a [ i ] [ j ] ; { for ( j = 0 ; j < 4 ; j ++ ) cout << setw ( 5 ) << a [ i ] [ j ] ; cout << endl ; } a

// 例4-9 访问二维数组 a #include <iostream> #include <iomanip> 4.3.2 二维数组访问 // 例4-9 访问二维数组 #include <iostream> #include <iomanip> using namespace std ; int main ( ) { int a [ 3 ] [ 4 ] ; int i , j ; for ( i = 0 ; i < 3 ; i ++ ) for ( j = 0 ; j < 4 ; j ++ ) cin >> a [ i ] [ j ] ; { for ( j = 0 ; j < 4 ; j ++ ) cout << setw ( 5 ) << a [ i ] [ j ] ; cout << endl ; } a i j

// 例4-9 访问二维数组 a #include <iostream> #include <iomanip> 4.3.2 二维数组访问 // 例4-9 访问二维数组 #include <iostream> #include <iomanip> using namespace std ; int main ( ) { int a [ 3 ] [ 4 ] ; int i , j ; for ( i = 0 ; i < 3 ; i ++ ) for ( j = 0 ; j < 4 ; j ++ ) cin >> a [ i ] [ j ] ; { for ( j = 0 ; j < 4 ; j ++ ) cout << setw ( 5 ) << a [ i ] [ j ] ; cout << endl ; } a i j

// 例4-9 访问二维数组 a #include <iostream> #include <iomanip> 4.3.2 二维数组访问 // 例4-9 访问二维数组 #include <iostream> #include <iomanip> using namespace std ; int main ( ) { int a [ 3 ] [ 4 ] ; int i , j ; for ( i = 0 ; i < 3 ; i ++ ) for ( j = 0 ; j < 4 ; j ++ ) cin >> a [ i ] [ j ] ; { for ( j = 0 ; j < 4 ; j ++ ) cout << setw ( 5 ) << a [ i ] [ j ] ; cout << endl ; } a i j

// 例4-9 访问二维数组 a #include <iostream> #include <iomanip> 4.3.2 二维数组访问 // 例4-9 访问二维数组 #include <iostream> #include <iomanip> using namespace std ; int main ( ) { int a [ 3 ] [ 4 ] ; int i , j ; for ( i = 0 ; i < 3 ; i ++ ) for ( j = 0 ; j < 4 ; j ++ ) cin >> a [ i ] [ j ] ; { for ( j = 0 ; j < 4 ; j ++ ) cout << setw ( 5 ) << a [ i ] [ j ] ; cout << endl ; } a 2 i j

// 例4-9 访问二维数组 a #include <iostream> #include <iomanip> 4.3.2 二维数组访问 // 例4-9 访问二维数组 #include <iostream> #include <iomanip> using namespace std ; int main ( ) { int a [ 3 ] [ 4 ] ; int i , j ; for ( i = 0 ; i < 3 ; i ++ ) for ( j = 0 ; j < 4 ; j ++ ) cin >> a [ i ] [ j ] ; { for ( j = 0 ; j < 4 ; j ++ ) cout << setw ( 5 ) << a [ i ] [ j ] ; cout << endl ; } a 2 i j 1

// 例4-9 访问二维数组 a #include <iostream> #include <iomanip> 4.3.2 二维数组访问 // 例4-9 访问二维数组 #include <iostream> #include <iomanip> using namespace std ; int main ( ) { int a [ 3 ] [ 4 ] ; int i , j ; for ( i = 0 ; i < 3 ; i ++ ) for ( j = 0 ; j < 4 ; j ++ ) cin >> a [ i ] [ j ] ; { for ( j = 0 ; j < 4 ; j ++ ) cout << setw ( 5 ) << a [ i ] [ j ] ; cout << endl ; } a 2 4 i j 1

// 例4-9 访问二维数组 a #include <iostream> #include <iomanip> 4.3.2 二维数组访问 // 例4-9 访问二维数组 #include <iostream> #include <iomanip> using namespace std ; int main ( ) { int a [ 3 ] [ 4 ] ; int i , j ; for ( i = 0 ; i < 3 ; i ++ ) for ( j = 0 ; j < 4 ; j ++ ) cin >> a [ i ] [ j ] ; { for ( j = 0 ; j < 4 ; j ++ ) cout << setw ( 5 ) << a [ i ] [ j ] ; cout << endl ; } a 2 4 i j 2

// 例4-9 访问二维数组 a #include <iostream> #include <iomanip> 4.3.2 二维数组访问 // 例4-9 访问二维数组 #include <iostream> #include <iomanip> using namespace std ; int main ( ) { int a [ 3 ] [ 4 ] ; int i , j ; for ( i = 0 ; i < 3 ; i ++ ) for ( j = 0 ; j < 4 ; j ++ ) cin >> a [ i ] [ j ] ; { for ( j = 0 ; j < 4 ; j ++ ) cout << setw ( 5 ) << a [ i ] [ j ] ; cout << endl ; } a 2 4 6 i j 2

// 例4-9 访问二维数组 a #include <iostream> #include <iomanip> 4.3.2 二维数组访问 // 例4-9 访问二维数组 #include <iostream> #include <iomanip> using namespace std ; int main ( ) { int a [ 3 ] [ 4 ] ; int i , j ; for ( i = 0 ; i < 3 ; i ++ ) for ( j = 0 ; j < 4 ; j ++ ) cin >> a [ i ] [ j ] ; { for ( j = 0 ; j < 4 ; j ++ ) cout << setw ( 5 ) << a [ i ] [ j ] ; cout << endl ; } a 2 4 6 i j 3

// 例4-9 访问二维数组 a #include <iostream> #include <iomanip> 4.3.2 二维数组访问 // 例4-9 访问二维数组 #include <iostream> #include <iomanip> using namespace std ; int main ( ) { int a [ 3 ] [ 4 ] ; int i , j ; for ( i = 0 ; i < 3 ; i ++ ) for ( j = 0 ; j < 4 ; j ++ ) cin >> a [ i ] [ j ] ; { for ( j = 0 ; j < 4 ; j ++ ) cout << setw ( 5 ) << a [ i ] [ j ] ; cout << endl ; } a 2 4 6 8 i j 3

// 例4-9 访问二维数组 a #include <iostream> #include <iomanip> 4.3.2 二维数组访问 // 例4-9 访问二维数组 #include <iostream> #include <iomanip> using namespace std ; int main ( ) { int a [ 3 ] [ 4 ] ; int i , j ; for ( i = 0 ; i < 3 ; i ++ ) for ( j = 0 ; j < 4 ; j ++ ) cin >> a [ i ] [ j ] ; { for ( j = 0 ; j < 4 ; j ++ ) cout << setw ( 5 ) << a [ i ] [ j ] ; cout << endl ; } a 2 4 6 8 i j 4

// 例4-9 访问二维数组 a #include <iostream> #include <iomanip> 4.3.2 二维数组访问 // 例4-9 访问二维数组 #include <iostream> #include <iomanip> using namespace std ; int main ( ) { int a [ 3 ] [ 4 ] ; int i , j ; for ( i = 0 ; i < 3 ; i ++ ) for ( j = 0 ; j < 4 ; j ++ ) cin >> a [ i ] [ j ] ; { for ( j = 0 ; j < 4 ; j ++ ) cout << setw ( 5 ) << a [ i ] [ j ] ; cout << endl ; } a 2 4 6 8 i 1 j 4

// 例4-9 访问二维数组 a #include <iostream> #include <iomanip> 4.3.2 二维数组访问 // 例4-9 访问二维数组 #include <iostream> #include <iomanip> using namespace std ; int main ( ) { int a [ 3 ] [ 4 ] ; int i , j ; for ( i = 0 ; i < 3 ; i ++ ) for ( j = 0 ; j < 4 ; j ++ ) cin >> a [ i ] [ j ] ; { for ( j = 0 ; j < 4 ; j ++ ) cout << setw ( 5 ) << a [ i ] [ j ] ; cout << endl ; } a 2 4 6 8 i 1 j

// 例4-9 访问二维数组 a #include <iostream> #include <iomanip> 4.3.2 二维数组访问 // 例4-9 访问二维数组 #include <iostream> #include <iomanip> using namespace std ; int main ( ) { int a [ 3 ] [ 4 ] ; int i , j ; for ( i = 0 ; i < 3 ; i ++ ) for ( j = 0 ; j < 4 ; j ++ ) cin >> a [ i ] [ j ] ; { for ( j = 0 ; j < 4 ; j ++ ) cout << setw ( 5 ) << a [ i ] [ j ] ; cout << endl ; } a 2 4 6 8 1 i 1 j

// 例4-9 访问二维数组 a #include <iostream> #include <iomanip> 4.3.2 二维数组访问 // 例4-9 访问二维数组 #include <iostream> #include <iomanip> using namespace std ; int main ( ) { int a [ 3 ] [ 4 ] ; int i , j ; for ( i = 0 ; i < 3 ; i ++ ) for ( j = 0 ; j < 4 ; j ++ ) cin >> a [ i ] [ j ] ; { for ( j = 0 ; j < 4 ; j ++ ) cout << setw ( 5 ) << a [ i ] [ j ] ; cout << endl ; } a 2 4 6 8 1 i 1 j 1

// 例4-9 访问二维数组 a #include <iostream> #include <iomanip> 4.3.2 二维数组访问 // 例4-9 访问二维数组 #include <iostream> #include <iomanip> using namespace std ; int main ( ) { int a [ 3 ] [ 4 ] ; int i , j ; for ( i = 0 ; i < 3 ; i ++ ) for ( j = 0 ; j < 4 ; j ++ ) cin >> a [ i ] [ j ] ; { for ( j = 0 ; j < 4 ; j ++ ) cout << setw ( 5 ) << a [ i ] [ j ] ; cout << endl ; } a 2 4 6 8 1 3 i 1 j 1

// 例4-9 访问二维数组 a #include <iostream> #include <iomanip> 4.3.2 二维数组访问 // 例4-9 访问二维数组 #include <iostream> #include <iomanip> using namespace std ; int main ( ) { int a [ 3 ] [ 4 ] ; int i , j ; for ( i = 0 ; i < 3 ; i ++ ) for ( j = 0 ; j < 4 ; j ++ ) cin >> a [ i ] [ j ] ; { for ( j = 0 ; j < 4 ; j ++ ) cout << setw ( 5 ) << a [ i ] [ j ] ; cout << endl ; } a 2 4 6 8 1 3 i 1 j 2

// 例4-9 访问二维数组 a #include <iostream> #include <iomanip> 4.3.2 二维数组访问 // 例4-9 访问二维数组 #include <iostream> #include <iomanip> using namespace std ; int main ( ) { int a [ 3 ] [ 4 ] ; int i , j ; for ( i = 0 ; i < 3 ; i ++ ) for ( j = 0 ; j < 4 ; j ++ ) cin >> a [ i ] [ j ] ; { for ( j = 0 ; j < 4 ; j ++ ) cout << setw ( 5 ) << a [ i ] [ j ] ; cout << endl ; } a 2 4 6 8 1 3 5 i 1 j 2

// 例4-9 访问二维数组 a #include <iostream> #include <iomanip> 4.3.2 二维数组访问 // 例4-9 访问二维数组 #include <iostream> #include <iomanip> using namespace std ; int main ( ) { int a [ 3 ] [ 4 ] ; int i , j ; for ( i = 0 ; i < 3 ; i ++ ) for ( j = 0 ; j < 4 ; j ++ ) cin >> a [ i ] [ j ] ; { for ( j = 0 ; j < 4 ; j ++ ) cout << setw ( 5 ) << a [ i ] [ j ] ; cout << endl ; } a 2 4 6 8 1 3 5 7 i 1 j 3

// 例4-9 访问二维数组 a #include <iostream> #include <iomanip> 4.3.2 二维数组访问 // 例4-9 访问二维数组 #include <iostream> #include <iomanip> using namespace std ; int main ( ) { int a [ 3 ] [ 4 ] ; int i , j ; for ( i = 0 ; i < 3 ; i ++ ) for ( j = 0 ; j < 4 ; j ++ ) cin >> a [ i ] [ j ] ; { for ( j = 0 ; j < 4 ; j ++ ) cout << setw ( 5 ) << a [ i ] [ j ] ; cout << endl ; } a 2 4 6 8 1 3 5 7 9 i 2 j

// 例4-9 访问二维数组 a #include <iostream> #include <iomanip> 4.3.2 二维数组访问 // 例4-9 访问二维数组 #include <iostream> #include <iomanip> using namespace std ; int main ( ) { int a [ 3 ] [ 4 ] ; int i , j ; for ( i = 0 ; i < 3 ; i ++ ) for ( j = 0 ; j < 4 ; j ++ ) cin >> a [ i ] [ j ] ; { for ( j = 0 ; j < 4 ; j ++ ) cout << setw ( 5 ) << a [ i ] [ j ] ; cout << endl ; } a 2 4 6 8 1 3 5 7 9 10 i 2 j 1

// 例4-9 访问二维数组 a #include <iostream> #include <iomanip> 4.3.2 二维数组访问 // 例4-9 访问二维数组 #include <iostream> #include <iomanip> using namespace std ; int main ( ) { int a [ 3 ] [ 4 ] ; int i , j ; for ( i = 0 ; i < 3 ; i ++ ) for ( j = 0 ; j < 4 ; j ++ ) cin >> a [ i ] [ j ] ; { for ( j = 0 ; j < 4 ; j ++ ) cout << setw ( 5 ) << a [ i ] [ j ] ; cout << endl ; } a 2 4 6 8 1 3 5 7 9 10 11 i 2 j 2

// 例4-9 访问二维数组 a #include <iostream> #include <iomanip> 4.3.2 二维数组访问 // 例4-9 访问二维数组 #include <iostream> #include <iomanip> using namespace std ; int main ( ) { int a [ 3 ] [ 4 ] ; int i , j ; for ( i = 0 ; i < 3 ; i ++ ) for ( j = 0 ; j < 4 ; j ++ ) cin >> a [ i ] [ j ] ; { for ( j = 0 ; j < 4 ; j ++ ) cout << setw ( 5 ) << a [ i ] [ j ] ; cout << endl ; } a 2 4 6 8 1 3 5 7 9 10 11 12 i 2 j 3

// 例4-9 访问二维数组 a #include <iostream> #include <iomanip> 4.3.2 二维数组访问 // 例4-9 访问二维数组 #include <iostream> #include <iomanip> using namespace std ; int main ( ) { int a [ 3 ] [ 4 ] ; int i , j ; for ( i = 0 ; i < 3 ; i ++ ) for ( j = 0 ; j < 4 ; j ++ ) cin >> a [ i ] [ j ] ; { for ( j = 0 ; j < 4 ; j ++ ) cout << setw ( 5 ) << a [ i ] [ j ] ; cout << endl ; } a 2 4 6 8 1 3 5 7 9 10 11 12 i 2 j 4

// 例4-9 访问二维数组 a #include <iostream> #include <iomanip> 4.3.2 二维数组访问 // 例4-9 访问二维数组 #include <iostream> #include <iomanip> using namespace std ; int main ( ) { int a [ 3 ] [ 4 ] ; int i , j ; for ( i = 0 ; i < 3 ; i ++ ) for ( j = 0 ; j < 4 ; j ++ ) cin >> a [ i ] [ j ] ; { for ( j = 0 ; j < 4 ; j ++ ) cout << setw ( 5 ) << a [ i ] [ j ] ; cout << endl ; } a 2 4 6 8 1 3 5 7 9 10 11 12 i 3 j 4

// 例4-9 访问二维数组 a #include <iostream> #include <iomanip> 4.3.2 二维数组访问 // 例4-9 访问二维数组 #include <iostream> #include <iomanip> using namespace std ; int main ( ) { int a [ 3 ] [ 4 ] ; int i , j ; for ( i = 0 ; i < 3 ; i ++ ) for ( j = 0 ; j < 4 ; j ++ ) cin >> a [ i ] [ j ] ; { for ( j = 0 ; j < 4 ; j ++ ) cout << setw ( 5 ) << a [ i ] [ j ] ; cout << endl ; } a 2 4 6 8 1 3 5 7 9 10 11 12 i j

// 例4-9 访问二维数组 a #include <iostream> #include <iomanip> 4.3.2 二维数组访问 // 例4-9 访问二维数组 #include <iostream> #include <iomanip> using namespace std ; int main ( ) { int a [ 3 ] [ 4 ] ; int i , j ; for ( i = 0 ; i < 3 ; i ++ ) for ( j = 0 ; j < 4 ; j ++ ) cin >> a [ i ] [ j ] ; { for ( j = 0 ; j < 4 ; j ++ ) cout << setw ( 5 ) << a [ i ] [ j ] ; cout << endl ; } a 2 4 6 8 1 3 5 7 9 10 11 12 i j

以上结论可以推广到多维数组， 二维数组的每一个元素是同构的一维数组 4.3.2 二维数组访问 2. 以指针方式访问二维数组 从一维数组元素的地址关系可知：  数组名代表数组的首地址  任一数组元素的地址，可以用数组名加偏移量表示 偏移量单位是数组元素的大小 地址值 元素值 a  & a[ 0 ] a [ 0 ]  * a a + 1  & a[ 1 ] a [ 1 ]  * ( a + 1 ) a + 2  & a[ 2 ] a [ 2 ]  * ( a + 2 ) : : a + i  & a[ i ] a [ i ]  * ( a + i ) 以上结论可以推广到多维数组， 二维数组的每一个元素是同构的一维数组

double a [3][5] *a a [0] [0] a a [ 0 ] *a[0] a [0] [1] *(*a+1) 4.3.2 二维数组访问 double a [3][5] a a+1 a+2 *a *(a+1) *(a+2) a [0] [0] a [0] [1] : a [1] [0] a [1] [1] a [2] [0] a [2] [1] 1000 1008 1040 1048 1080 1088 a [ 0 ] a [ 1 ] a [ 2 ] *a[0] *(*a+1) *a[1] *(*(a+1)+1) a [ 0 ] + 1 * a + 1 a [ 1 ] + 1 * ( a+1) + 1 a [ 2 ] + 1 * ( a+2) + 1

二维数组名 a 是逻辑上的一个二级指针, a [ i ] 是一级指针 用二维数组名引用基本类型时，应当是二级引用，但不能 4.3.2 二维数组访问 2. 以指针方式访问二维数组 二维数组名 a 是逻辑上的一个二级指针, a [ i ] 是一级指针 用二维数组名引用基本类型时，应当是二级引用，但不能 直接把二维数组名赋给二级指针变量，因为不管 n 维数组， 数组名仅是内存块首地址 例： int a [ 3 ] [ 5 ] , **p2 , *p1 ; p1 = * a ; // OK p1 = a [ 0 ] ; // OK p2 = a ; // Error p1 = a ; // Error

第0行第1列元素地址 a [0]+1 *a+1 &a[0] [1] 4.3.2 二维数组访问 2. 以指针方式访问二维数组 a [0] [0] a [0] [1] : a [1] [0] a [1] [1] a [2] [0] a [2] [1] 1000 1004 1020 1024 1030 1034 int a [3] [5] 的表示形式: 第0行第1列元素地址 a [0]+1 *a+1 &a[0] [1] 第1行第2列元素地址 a [1]+2 *(a+1)+2 &a[1] [2] 第 i 行第 j 列元素地址 a [ i ]+j *(a+i)+j &a[i] [j] 第1行第2列元素的值 *(a [ 1 ]+2) *( *(a+1)+2) a[1] [2] 第 i 行第 j 列元素的值 *(a [ i ]+j) *( *(a+i)+j) a[i] [j]

#include<iostream> using namespace std ; int main() 4.3.2 二维数组访问 2. 以指针方式访问二维数组 // 例4-10 #include<iostream> using namespace std ; int main() { int a[3] [5] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 } ; int * p ; for ( p = a [ 0 ] ; p < a[ 0 ] + 15 ; p ++ ) cout << *p << " " ; cout << endl ; for ( p = * a ; p < *a + 15 ; p ++ ) for ( int i = 0 ; i < 3 ; i ++ ) { for ( int j = 0 ; j < 5 ; j ++ ) cout << * ( a [ i ] + j ) << " " ; }

#include<iostream> using namespace std ; int main() 4.3.2 二维数组访问 2. 以指针方式访问二维数组 // 例4-10 #include<iostream> using namespace std ; int main() { int a[3] [5] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 } ; int * p ; for ( p = a [ 0 ] ; p < a[ 0 ] + 15 ; p ++ ) cout << *p << " " ; cout << endl ; for ( p = * a ; p < *a + 15 ; p ++ ) for ( int i = 0 ; i < 3 ; i ++ ) { for ( int j = 0 ; j < 5 ; j ++ ) cout << * ( a [ i ] + j ) << " " ; } 取第 0 行元素的首地址

#include<iostream> using namespace std ; int main() 4.3.2 二维数组访问 2. 以指针方式访问二维数组 // 例4-10 #include<iostream> using namespace std ; int main() { int a[3] [5] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 } ; int * p ; for ( p = a [ 0 ] ; p < a[ 0 ] + 15 ; p ++ ) cout << *p << " " ; cout << endl ; for ( p = * a ; p < *a + 15 ; p ++ ) for ( int i = 0 ; i < 3 ; i ++ ) { for ( int j = 0 ; j < 5 ; j ++ ) cout << * ( a [ i ] + j ) << " " ; } 第 i 行第 j 个元素

No ! 2. 以指针方式访问二维数组 // 例4-10 #include<iostream> 4.3.2 二维数组访问 2. 以指针方式访问二维数组 // 例4-10 #include<iostream> using namespace std ; int main() { int a[3] [5] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 } ; int * p ; for ( p = a [ 0 ] ; p < a[ 0 ] + 15 ; p ++ ) cout << *p << " " ; cout << endl ; for ( p = * a ; p < *a + 15 ; p ++ ) for ( int i = 0 ; i < 3 ; i ++ ) { for ( int j = 0 ; j < 5 ; j ++ ) cout << * ( a [ i ] + j ) << " " ; } 可以改为 p = a 吗？ No ! a 是逻辑上的二级指针， 不能把 a 赋给一级指针变量

No ! 2. 以指针方式访问二维数组 // 例4-10 #include<iostream> 4.3.2 二维数组访问 2. 以指针方式访问二维数组 // 例4-10 #include<iostream> using namespace std ; int main() { int a[3] [5] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 } ; int * p ; for ( p = a [ 0 ] ; p < a[ 0 ] + 15 ; p ++ ) cout << *p << " " ; cout << endl ; for ( p = * a ; p < *a + 15 ; p ++ ) for ( int i = 0 ; i < 3 ; i ++ ) { for ( int j = 0 ; j < 5 ; j ++ ) cout << * ( a [ i ] + j ) << " " ; } 可以改为 p = a[0][0] 吗？ No ! a[0][0] 是数组元素值 不能赋给指针变量

OK ! 2. 以指针方式访问二维数组 // 例4-10 #include<iostream> 4.3.2 二维数组访问 2. 以指针方式访问二维数组 // 例4-10 #include<iostream> using namespace std ; int main() { int a[3] [5] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 } ; int * p ; for ( p = a [ 0 ] ; p < a[ 0 ] + 15 ; p ++ ) cout << *p << " " ; cout << endl ; for ( p = * a ; p < *a + 15 ; p ++ ) for ( int i = 0 ; i < 3 ; i ++ ) { for ( int j = 0 ; j < 5 ; j ++ ) cout << * ( a [ i ] + j ) << " " ; } 可以改为 p = &a[0][0] 吗？ OK !

#include<iostream> using namespace std ; int main() 4.3.2 二维数组访问 2. 以指针方式访问二维数组 // 例4-10 #include<iostream> using namespace std ; int main() { int a[3] [5] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 } ; int * p ; for ( p = a [ 0 ] ; p < a[ 0 ] + 15 ; p ++ ) cout << *p << " " ; cout << endl ; for ( p = * a ; p < *a + 15 ; p ++ ) for ( int i = 0 ; i < 3 ; i ++ ) { for ( int j = 0 ; j < 5 ; j ++ ) cout << * ( a [ i ] + j ) << " " ; } 注意 对二维数组不同的处理方式

#include<iostream> using namespace std ; int main() 4.3.2 二维数组访问 2. 以指针方式访问二维数组 // 例4-10 #include<iostream> using namespace std ; int main() { int a[3] [5] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 } ; int * p ; for ( p = a [ 0 ] ; p < a[ 0 ] + 15 ; p ++ ) cout << *p << " " ; cout << endl ; for ( p = * a ; p < *a + 15 ; p ++ ) for ( int i = 0 ; i < 3 ; i ++ ) { for ( int j = 0 ; j < 5 ; j ++ ) cout << * ( a [ i ] + j ) << " " ; }

4.4 数组作函数参数 数组元素作参数的性质与简单变量相同 数组名作参数传递地址 数组元素和数组名都可以作为引用参数

4.4.1 向函数传送数组元素 // 例4-11 #include<iomanip> 4.4.1 向函数传送数组元素 // 例4-11 #include<iomanip> #include<iostream> using namespace std ; void fun( int, int, int ); int main() { int i , a[3] = { 1, 2, 3 } ; fun ( a[0] , a[1] , a[2] ) ; for ( i = 0 ; i < 3 ; i ++ ) cout << setw( 4 ) << a [ i ] ; cout << endl ; } void fun ( int a, int b, int c ) { a++ ; b++ ; c++ ; cout << setw( 4 ) << a << setw( 4 ) << b << setw( 4 ) << c << endl ; return ;

4.4.1 向函数传送数组元素 // 例4-11 #include<iomanip> 4.4.1 向函数传送数组元素 // 例4-11 #include<iomanip> #include<iostream> using namespace std ; void fun( int, int, int ); int main() { int i , a[3] = { 1, 2, 3 } ; fun ( a[0] , a[1] , a[2] ) ; for ( i = 0 ; i < 3 ; i ++ ) cout << setw( 4 ) << a [ i ] ; cout << endl ; } void fun ( int a , int b , int c ) { a++ ; b++ ; c++ ; cout << setw( 4 ) << a << setw( 4 ) << b << setw( 4 ) << c << endl ; return ; 传值参数

4.4.1 向函数传送数组元素 // 例4-11 #include<iomanip> 4.4.1 向函数传送数组元素 // 例4-11 #include<iomanip> #include<iostream> using namespace std ; void fun( int, int, int ); int main() { int i , a[3] = { 1, 2, 3 } ; fun ( a[0] , a[1] , a[2] ) ; for ( i = 0 ; i < 3 ; i ++ ) cout << setw( 4 ) << a [ i ] ; cout << endl ; } void fun ( int a , int b , int c ) { a++ ; b++ ; c++ ; cout << setw( 4 ) << a << setw( 4 ) << b << setw( 4 ) << c << endl ; return ; 修改局部量

4.4.1 向函数传送数组元素 // 例4-11 #include<iomanip> 4.4.1 向函数传送数组元素 // 例4-11 #include<iomanip> #include<iostream> using namespace std ; void fun( int, int, int ); int main() { int i , a[3] = { 1, 2, 3 } ; fun ( a[0] , a[1] , a[2] ) ; for ( i = 0 ; i < 3 ; i ++ ) cout << setw( 4 ) << a [ i ] ; cout << endl ; } void fun ( int a , int b , int c ) { a++ ; b++ ; c++ ; cout << setw( 4 ) << a << setw( 4 ) << b << setw( 4 ) << c << endl ; return ;

4.4.2 数组名作函数参数 // 例4-12 #include <iostream> 4.4.2 数组名作函数参数 // 例4-12 #include <iostream> using namespace std ; int sum ( int ap[ ] , int n ) { int m = 0 ; for ( int i = 0 ; i < n ; i ++ ) { m += * ap ; ap ++ ; } return m; int main() { int a [ 10 ] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 } ; cout << "sum = " << sum ( a , 10 ) << endl ;

4.4.2 数组名作函数参数 a 0x0065FDD0 // 例4-12 1 #include <iostream> 2 4.4.2 数组名作函数参数 4.4.2 数组名作函数参数 a 0x0065FDD0 1 2 3 4 5 6 7 8 9 10 // 例4-12 #include <iostream> using namespace std ; int sum ( int ap[ ] , int n ) { int m = 0 ; for ( int i = 0 ; i < n ; i ++ ) { m += * ap ; ap ++ ; } return m; int main() { int a [ 10 ] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 } ; cout << "sum = " << sum ( a , 10 ) << endl ;

4.4.2 数组名作函数参数 a 0x0065FDD0 // 例4-12 1 #include <iostream> 2 4.4.2 数组名作函数参数 4.4.2 数组名作函数参数 a 0x0065FDD0 1 2 3 4 5 6 7 8 9 10 // 例4-12 #include <iostream> using namespace std ; int sum ( int ap[ ] , int n ) { int m = 0 ; for ( int i = 0 ; i < n ; i ++ ) { m += * ap ; ap ++ ; } return m; int main() { int a [ 10 ] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 } ; cout << "sum = " << sum ( a , 10 ) << endl ;

4.4.2 数组名作函数参数 n a 0x0065FDD0 ap // 例4-12 1 #include <iostream> 4.4.2 数组名作函数参数 4.4.2 数组名作函数参数 a 0x0065FDD0 1 2 3 4 5 6 7 8 9 10 ap n // 例4-12 #include <iostream> using namespace std ; int sum ( int ap[ ] , int n ) { int m = 0 ; for ( int i = 0 ; i < n ; i ++ ) { m += * ap ; ap ++ ; } return m; int main() { int a [ 10 ] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 } ; cout << "sum = " << sum ( a , 10 ) << endl ;

4.4.2 数组名作函数参数 10 n a 0x0065FDD0 ap // 例4-12 1 4.4.2 数组名作函数参数 4.4.2 数组名作函数参数 a 0x0065FDD0 1 2 3 4 5 6 7 8 9 10 0x0065FDD0 ap 10 n // 例4-12 #include <iostream> using namespace std ; int sum ( int ap[ ] , int n ) { int m = 0 ; for ( int i = 0 ; i < n ; i ++ ) { m += * ap ; ap ++ ; } return m; int main() { int a [ 10 ] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 } ; cout << "sum = " << sum ( a , 10 ) << endl ;

4.4.2 数组名作函数参数 10 n a 0x0065FDD0 ap // 例4-12 1 4.4.2 数组名作函数参数 4.4.2 数组名作函数参数 a 0x0065FDD0 1 2 3 4 5 6 7 8 9 10 10 n // 例4-12 #include <iostream> using namespace std ; int sum ( int ap[ ] , int n ) { int m = 0 ; for ( int i = 0 ; i < n ; i ++ ) { m += * ap ; ap ++ ; } return m; int main() { int a [ 10 ] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 } ; cout << "sum = " << sum ( a , 10 ) << endl ; 0x0065FDD0 ap

4.4.2 数组名作函数参数 10 n a 0x0065FDD0 ap // 例4-12 1 4.4.2 数组名作函数参数 4.4.2 数组名作函数参数 a 0x0065FDD0 1 2 3 4 5 6 7 8 9 10 10 n // 例4-12 #include <iostream> using namespace std ; int sum ( int ap[ ] , int n ) { int m = 0 ; for ( int i = 0 ; i < n ; i ++ ) { m += * ap ; ap ++ ; } return m; int main() { int a [ 10 ] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 } ; cout << "sum = " << sum ( a , 10 ) << endl ; 0x0065FDD0 ap m

4.4.2 数组名作函数参数 10 n a 0x0065FDD0 ap // 例4-12 1 4.4.2 数组名作函数参数 4.4.2 数组名作函数参数 a 0x0065FDD0 1 2 3 4 5 6 7 8 9 10 10 n // 例4-12 #include <iostream> using namespace std ; int sum ( int ap[ ] , int n ) { int m = 0 ; for ( int i = 0 ; i < n ; i ++ ) { m += * ap ; ap ++ ; } return m; int main() { int a [ 10 ] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 } ; cout << "sum = " << sum ( a , 10 ) << endl ; 0x0065FDD0 ap m i

4.4.2 数组名作函数参数 4.4.2 数组名作函数参数 a 0x0065FDD0 1 2 3 4 5 6 7 8 9 10 10 n // 例4-12 #include <iostream> using namespace std ; int sum ( int ap[ ] , int n ) { int m = 0 ; for ( int i = 0 ; i < n ; i ++ ) { m += * ap ; ap ++ ; } return m; int main() { int a [ 10 ] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 } ; cout << "sum = " << sum ( a , 10 ) << endl ; 0x0065FDD0 ap 1 m i

4.4.2 数组名作函数参数 4.4.2 数组名作函数参数 a 0x0065FDD0 1 2 3 4 5 6 7 8 9 10 10 n // 例4-12 #include <iostream> using namespace std ; int sum ( int ap[ ] , int n ) { int m = 0 ; for ( int i = 0 ; i < n ; i ++ ) { m += * ap ; ap ++ ; } return m; int main() { int a [ 10 ] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 } ; cout << "sum = " << sum ( a , 10 ) << endl ; 0x0065FDD4 ap 1 m i

4.4.2 数组名作函数参数 4.4.2 数组名作函数参数 a 0x0065FDD0 1 2 3 4 5 6 7 8 9 10 10 n // 例4-12 #include <iostream> using namespace std ; int sum ( int ap[ ] , int n ) { int m = 0 ; for ( int i = 0 ; i < n ; i ++ ) { m += * ap ; ap ++ ; } return m; int main() { int a [ 10 ] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 } ; cout << "sum = " << sum ( a , 10 ) << endl ; 0x0065FDD4 ap 1 m 1 i

4.4.2 数组名作函数参数 4.4.2 数组名作函数参数 a 0x0065FDD0 1 2 3 4 5 6 7 8 9 10 10 n // 例4-12 #include <iostream> using namespace std ; int sum ( int ap[ ] , int n ) { int m = 0 ; for ( int i = 0 ; i < n ; i ++ ) { m += * ap ; ap ++ ; } return m; int main() { int a [ 10 ] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 } ; cout << "sum = " << sum ( a , 10 ) << endl ; 0x0065FDD4 ap 3 m 1 i

4.4.2 数组名作函数参数 4.4.2 数组名作函数参数 a 0x0065FDD0 1 2 3 4 5 6 7 8 9 10 10 n // 例4-12 #include <iostream> using namespace std ; int sum ( int ap[ ] , int n ) { int m = 0 ; for ( int i = 0 ; i < n ; i ++ ) { m += * ap ; ap ++ ; } return m; int main() { int a [ 10 ] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 } ; cout << "sum = " << sum ( a , 10 ) << endl ; 0x0065FDD8 ap 3 m 1 i

4.4.2 数组名作函数参数 4.4.2 数组名作函数参数 a 0x0065FDD0 1 2 3 4 5 6 7 8 9 10 10 n // 例4-12 #include <iostream> using namespace std ; int sum ( int ap[ ] , int n ) { int m = 0 ; for ( int i = 0 ; i < n ; i ++ ) { m += * ap ; ap ++ ; } return m; int main() { int a [ 10 ] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 } ; cout << "sum = " << sum ( a , 10 ) << endl ; 0x0065FDD8 ap 3 m 2 i

4.4.2 数组名作函数参数 4.4.2 数组名作函数参数 a 0x0065FDD0 1 2 3 4 5 6 7 8 9 10 10 n // 例4-12 #include <iostream> using namespace std ; int sum ( int ap[ ] , int n ) { int m = 0 ; for ( int i = 0 ; i < n ; i ++ ) { m += * ap ; ap ++ ; } return m; int main() { int a [ 10 ] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 } ; cout << "sum = " << sum ( a , 10 ) << endl ; 0x0065FDD8 ap 6 m 2 i

4.4.2 数组名作函数参数 4.4.2 数组名作函数参数 a 0x0065FDD0 1 2 3 4 5 6 7 8 9 10 10 n // 例4-12 #include <iostream> using namespace std ; int sum ( int ap[ ] , int n ) { int m = 0 ; for ( int i = 0 ; i < n ; i ++ ) { m += * ap ; ap ++ ; } return m; int main() { int a [ 10 ] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 } ; cout << "sum = " << sum ( a , 10 ) << endl ; 0x0065FDDC ap 6 m 2 i

4.4.2 数组名作函数参数 4.4.2 数组名作函数参数 a 0x0065FDD0 1 2 3 4 5 6 7 8 9 10 10 n // 例4-12 #include <iostream> using namespace std ; int sum ( int ap[ ] , int n ) { int m = 0 ; for ( int i = 0 ; i < n ; i ++ ) { m += * ap ; ap ++ ; } return m; int main() { int a [ 10 ] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 } ; cout << "sum = " << sum ( a , 10 ) << endl ; 0x0065FDF8 ap 55 m 10 i

4.4.2 数组名作函数参数 4.4.2 数组名作函数参数 a 0x0065FDD0 1 2 3 4 5 6 7 8 9 10 10 n // 例4-12 #include <iostream> using namespace std ; int sum ( int ap[ ] , int n ) { int m = 0 ; for ( int i = 0 ; i < n ; i ++ ) { m += * ap ; ap ++ ; } return m; int main() { int a [ 10 ] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 } ; cout << "sum = " << sum ( a , 10 ) << endl ; 0x0065FDF8 ap 55 m 10 i

4.4.2 数组名作函数参数 // 例4-12 #include <iostream> a 0x0065FDD0 ap 1 4.4.2 数组名作函数参数 4.4.2 数组名作函数参数 a 0x0065FDD0 1 2 3 4 5 6 7 8 9 10 // 例4-12 #include <iostream> using namespace std ; int sum ( int ap[ ] , int n ) { int m = 0 ; for ( int i = 0 ; i < n ; i ++ ) { m += * ap ; ap ++ ; } return m; int main() { int a [ 10 ] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 } ; cout << "sum = " << sum ( a , 10 ) << endl ; 0x0065FDD0 ap 形参仅仅是一个普通指针 等价于 int * ap

4.4.2 数组名作函数参数 // 例4-12 #include <iostream> a 0x0065FDD0 ap 1 4.4.2 数组名作函数参数 4.4.2 数组名作函数参数 a 0x0065FDD0 1 2 3 4 5 6 7 8 9 10 // 例4-12 #include <iostream> using namespace std ; int sum ( int ap[ ] , int n ) { int m = 0 ; for ( int i = 0 ; i < n ; i ++ ) { m += * ap ; ap ++ ; } return m; int main() { int a [ 10 ] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 } ; cout << "sum = " << sum ( a , 10 ) << endl ; 0x0065FDD0 ap 修改指针 是合法操作

4.4.2 数组名作函数参数 // 例4-12 #include <iostream> a 0x0065FDD0 1 4.4.2 数组名作函数参数 4.4.2 数组名作函数参数 a 0x0065FDD0 1 2 3 4 5 6 7 8 9 10 // 例4-12 #include <iostream> using namespace std ; int sum ( int ap[ ] , int n ) { int m = 0 ; for ( int i = 0 ; i < n ; i ++ ) { m += * ap ; ap ++ ; } return m; int main() { int a [ 10 ] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 } ; cout << "sum = " << sum ( a , 10 ) << endl ; 0x0065FDD4 ap 修改指针 是合法操作

4.4.2 数组名作函数参数 // 例4-12 #include <iostream> a 0x0065FDD0 1 4.4.2 数组名作函数参数 4.4.2 数组名作函数参数 a 0x0065FDD0 1 2 3 4 5 6 7 8 9 10 // 例4-12 #include <iostream> using namespace std ; int sum ( int ap[ ] , int n ) { int m = 0 ; for ( int i = 0 ; i < n ; i ++ ) { m += * ap ; ap ++ ; } return m; int main() { int a [ 10 ] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 } ; cout << "sum = " << sum ( a , 10 ) << endl ; 0x0065FDD4 ap 但 a ++ 是非法操作

4.4.2 数组名作函数参数 // 例4-12 #include <iostream> a 0x0065FDD0 1 4.4.2 数组名作函数参数 4.4.2 数组名作函数参数 a 0x0065FDD0 1 2 3 4 5 6 7 8 9 10 // 例4-12 #include <iostream> using namespace std ; int sum ( int ap[ ] , int n ) { int m = 0 ; for ( int i = 0 ; i < n ; i ++ ) { m += * ap ; ap ++ ; } return m; int main() { int a [ 10 ] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 } ; cout << "sum = " << sum ( a , 10 ) << endl ; 0x0065FDD4 ap ( const int ap[ ] , int n ) 意义是什么？

4.4.2 数组名作函数参数 // 例4-12 #include <iostream> a 0x0065FDD0 1 4.4.2 数组名作函数参数 4.4.2 数组名作函数参数 a 0x0065FDD0 1 2 3 4 5 6 7 8 9 10 // 例4-12 #include <iostream> using namespace std ; int sum ( int ap[ ] , int n ) { int m = 0 ; for ( int i = 0 ; i < n ; i ++ ) { m += * ap ; ap ++ ; } return m; int main() { int a [ 10 ] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 } ; cout << "sum = " << sum ( a , 10 ) << endl ; 0x0065FDD4 ap ( const int ap[ ] , int n ) 对数组元素 只读访问

? // 例4-13 分析程序的输出结果 # include <iostream> using namespace std ; 4.4.2 数组名作函数参数 // 例4-13 分析程序的输出结果 # include <iostream> using namespace std ; void test ( int ap[] , double bp[] , char cp [] ) { cout << "sizeof ( ap ) = " << sizeof ( ap ) << endl ; cout << "sizeof ( bp ) = " << sizeof ( bp ) << endl ; cout << "sizeof ( cp ) = " << sizeof ( cp ) << endl ; } int main() { int a [ 10 ] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 } ; double b [ 10 ] = { 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0 } ; char c [ 10 ] = { 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j' } ; cout << "sizeof ( a ) = " << sizeof ( a ) << endl ; cout << "sizeof ( b ) = " << sizeof ( b ) << endl ; cout << "sizeof ( c ) = " << sizeof ( c ) << endl ; test ( a, b, c ) ; a 0x0065FDD0 1 2 3 4 5 6 7 8 9 10 0x0065FDD4 ap ?

? // 例4-13 分析程序的输出结果 # include <iostream> using namespace std ; 4.4.2 数组名作函数参数 // 例4-13 分析程序的输出结果 # include <iostream> using namespace std ; void test ( int ap[] , double bp[] , char cp [] ) { cout << "sizeof ( ap ) = " << sizeof ( ap ) << endl ; cout << "sizeof ( bp ) = " << sizeof ( bp ) << endl ; cout << "sizeof ( cp ) = " << sizeof ( cp ) << endl ; } int main() { int a [ 10 ] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 } ; double b [ 10 ] = { 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0 } ; char c [ 10 ] = { 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j' } ; cout << "sizeof ( a ) = " << sizeof ( a ) << endl ; cout << "sizeof ( b ) = " << sizeof ( b ) << endl ; cout << "sizeof ( c ) = " << sizeof ( c ) << endl ; test ( a, b, c ) ; a 0x0065FDD0 1 2 3 4 5 6 7 8 9 10 0x0065FDD4 ap 0x0065FDD4 ap ?

? // 例4-13 分析程序的输出结果 # include <iostream> using namespace std ; 4.4.2 数组名作函数参数 // 例4-13 分析程序的输出结果 # include <iostream> using namespace std ; void test ( int ap[] , double bp[] , char cp [] ) { cout << "sizeof ( ap ) = " << sizeof ( ap ) << endl ; cout << "sizeof ( bp ) = " << sizeof ( bp ) << endl ; cout << "sizeof ( cp ) = " << sizeof ( cp ) << endl ; } int main() { int a [ 10 ] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 } ; double b [ 10 ] = { 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0 } ; char c [ 10 ] = { 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j' } ; cout << "sizeof ( a ) = " << sizeof ( a ) << endl ; cout << "sizeof ( b ) = " << sizeof ( b ) << endl ; cout << "sizeof ( c ) = " << sizeof ( c ) << endl ; test ( a, b, c ) ; a 0x0065FDD0 1 2 3 4 5 6 7 8 9 10 0x0065FDD4 ap sizeof(int*) 0x0065FDD4 ap ? sizeof(int[10])

( int * ap , double * bp , char * cp ) 4.4.2 数组名作函数参数 // 例4-13 分析程序的输出结果 # include <iostream> using namespace std ; void test ( int ap[] , double bp[] , char cp [] ) { cout << "sizeof ( ap ) = " << sizeof ( ap ) << endl ; cout << "sizeof ( bp ) = " << sizeof ( bp ) << endl ; cout << "sizeof ( cp ) = " << sizeof ( cp ) << endl ; } int main() { int a [ 10 ] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 } ; double b [ 10 ] = { 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0 } ; char c [ 10 ] = { 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j' } ; cout << "sizeof ( a ) = " << sizeof ( a ) << endl ; cout << "sizeof ( b ) = " << sizeof ( b ) << endl ; cout << "sizeof ( c ) = " << sizeof ( c ) << endl ; test ( a, b, c ) ; 有区别吗？ a 0x0065FDD0 1 2 3 4 5 6 7 8 9 10 0x0065FDD4 ap ( int * ap , double * bp , char * cp ) 可以吗？ int * a = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 } ;

( int * ap , double * bp , char * cp ) 4.4.2 数组名作函数参数 // 例4-13 分析程序的输出结果 # include <iostream> using namespace std ; void test ( int ap[] , double bp[] , char cp [] ) { cout << "sizeof ( ap ) = " << sizeof ( ap ) << endl ; cout << "sizeof ( bp ) = " << sizeof ( bp ) << endl ; cout << "sizeof ( cp ) = " << sizeof ( cp ) << endl ; } int main() { int a [ 10 ] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 } ; double b [ 10 ] = { 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0 } ; char c [ 10 ] = { 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j' } ; cout << "sizeof ( a ) = " << sizeof ( a ) << endl ; cout << "sizeof ( b ) = " << sizeof ( b ) << endl ; cout << "sizeof ( c ) = " << sizeof ( c ) << endl ; test ( a, b, c ) ; a 0x0065FDD0 1 2 3 4 5 6 7 8 9 10 0x0065FDD4 ap Ok ( int * ap , double * bp , char * cp ) No int * a = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 } ;

4.4.3 应用举例 数据排序是指对数据按关键字大小重新整理 按照排序的算法、时间空间效率，有许多种排序法 本节讨论两种简单排序法： 4.4.3 应用举例 4.4.3 应用举例 数据排序是指对数据按关键字大小重新整理 按照排序的算法、时间空间效率，有许多种排序法 本节讨论两种简单排序法： 选择排序法 冒泡排序法

1. 选择排序法 算法分析： 按降序排列 若一组整数放在数组a[0],a [1],……,a[n-1]中， 4.4.3 应用举例 1. 选择排序法 算法分析： 按降序排列 若一组整数放在数组a[0],a [1],……,a[n-1]中， 第一趟在a[0]～a[n-1]找出最大值，放在a[0]; 第二趟在a[1]～a[n-1]找出最大值，放在a[1]; …… 依此类推，直到从a[n-2]和a[n-1]之中找最大值

1. 选择排序法 算法描述： for( i=0; i<n-1; i ++ ) { * 从a[i]到a[n-1]中找最大元素a[t]; 4.4.3 应用举例 1. 选择排序法 算法描述： for( i=0; i<n-1; i ++ ) { * 从a[i]到a[n-1]中找最大元素a[t]; 把 a [ t ] 与 a [ i ] 交换 } * 细化寻找最大元素算法: 每一趟寻找中，设变量 t，记录当前最大元素下标： for( j=i+1; j<n; j ++ ) if( a[j]>a[t] ) t=j;

1. 选择排序法 for ( i = 0 ; i < n-1 ; i ++ ) // n = 4 { t = i ; 4.4.3 应用举例 1. 选择排序法 for ( i = 0 ; i < n-1 ; i ++ ) // n = 4 { t = i ; for ( j = i + 1 ; j < n ; j ++ ) if ( a[ j ] > a [ t ] ) t = j ; 把 a [ t ] 与 a [ i ] 交换 } 49 38 65 97 76 a [ 0 ] a [ 1 ] a [ 2 ] a [ 3 ] a [ 4 ] i j t 1 49 38 a [ 1 ] < a [ 0 ] a [ 1 ] : a [ 0 ]

1. 选择排序法 49 38 65 97 76 a [ 0 ] a [ 1 ] a [ 2 ] a [ 3 ] a [ 4 ] i 1 j 4.4.3 应用举例 1. 选择排序法 49 38 65 97 76 a [ 0 ] a [ 1 ] a [ 2 ] a [ 3 ] a [ 4 ] i 1 j t for ( i = 0 ; i < n-1 ; i ++ ) // n = 4 { t = i ; for ( j = i + 1 ; j < n ; j ++ ) if ( a[ j ] > a [ t ] ) t = j ; 把 a [ t ] 与 a [ i ] 交换 } 2 2 49 65 a [ 2 ] > a [ 0 ] a [ 2 ] : a [ 0 ]

1. 选择排序法 49 38 65 97 76 a [ 0 ] a [ 1 ] a [ 2 ] a [ 3 ] a [ 4 ] i 2 j 4.4.3 应用举例 1. 选择排序法 49 38 65 97 76 a [ 0 ] a [ 1 ] a [ 2 ] a [ 3 ] a [ 4 ] i 2 j t for ( i = 0 ; i < n-1 ; i ++ ) // n = 4 { t = i ; for ( j = i + 1 ; j < n ; j ++ ) if ( a[ j ] > a [ t ] ) t = j ; 把 a [ t ] 与 a [ i ] 交换 } 3 3 65 a [ 3 ] > a [ 2 ] 97 a [ 3 ] : a [ 2 ]

1. 选择排序法 49 38 65 97 76 a [ 0 ] a [ 1 ] a [ 2 ] a [ 3 ] a [ 4 ] i 3 j 4.4.3 应用举例 1. 选择排序法 49 38 65 97 76 a [ 0 ] a [ 1 ] a [ 2 ] a [ 3 ] a [ 4 ] i 3 j t for ( i = 0 ; i < n-1 ; i ++ ) // n = 4 { t = i ; for ( j = i + 1 ; j < n ; j ++ ) if ( a[ j ] > a [ t ] ) t = j ; 把 a [ t ] 与 a [ i ] 交换 } 4 a [ 4 ] < a [ 3 ] 97 a [ 4 ] : a [ 3 ] 76

1. 选择排序法 for ( i = 0 ; i < n-1 ; i ++ ) // n = 4 { t = i ; 4.4.3 应用举例 1. 选择排序法 for ( i = 0 ; i < n-1 ; i ++ ) // n = 4 { t = i ; for ( j = i + 1 ; j < n ; j ++ ) if ( a[ j ] > a [ t ] ) t = j ; 把 a [ t ] 与 a [ i ] 交换 } 49 38 65 97 76 a [ 0 ] a [ 1 ] a [ 2 ] a [ 3 ] a [ 4 ] i 5 j 3 t 97 a [ 0 ] a [ 3 ] 49

1. 选择排序法 97 38 65 49 76 a [ 0 ] a [ 1 ] a [ 2 ] a [ 3 ] a [ 4 ] i 5 j 4.4.3 应用举例 1. 选择排序法 97 38 65 49 76 a [ 0 ] a [ 1 ] a [ 2 ] a [ 3 ] a [ 4 ] i 5 j 3 t for ( i = 0 ; i < n-1 ; i ++ ) // n = 4 { t = i ; for ( j = i + 1 ; j < n ; j ++ ) if ( a[ j ] > a [ t ] ) t = j ; 把 a [ t ] 与 a [ i ] 交换 } 1 2 2 1 38 65 a [ 2 ] > a [ 1 ] a [ 2 ] : a [ 1 ]

1. 选择排序法 97 38 65 49 76 a [ 0 ] a [ 1 ] a [ 2 ] a [ 3 ] a [ 4 ] 1 i 2 4.4.3 应用举例 1. 选择排序法 97 38 65 49 76 a [ 0 ] a [ 1 ] a [ 2 ] a [ 3 ] a [ 4 ] 1 i 2 j t for ( i = 0 ; i < n-1 ; i ++ ) // n = 4 { t = i ; for ( j = i + 1 ; j < n ; j ++ ) if ( a[ j ] > a [ t ] ) t = j ; 把 a [ t ] 与 a [ i ] 交换 } 3 65 a [ 3 ] < a [ 2 ] 49 a [ 3 ] : a [ 2 ]

1. 选择排序法 97 38 65 49 76 a [ 0 ] a [ 1 ] a [ 2 ] a [ 3 ] a [ 4 ] 1 i 3 4.4.3 应用举例 1. 选择排序法 97 38 65 49 76 a [ 0 ] a [ 1 ] a [ 2 ] a [ 3 ] a [ 4 ] 1 i 3 j 2 t for ( i = 0 ; i < n-1 ; i ++ ) // n = 4 { t = i ; for ( j = i + 1 ; j < n ; j ++ ) if ( a[ j ] > a [ t ] ) t = j ; 把 a [ t ] 与 a [ i ] 交换 } 4 4 65 a [ 4 ] > a [ 2 ] a [ 4 ] : a [ 2 ] 76

1. 选择排序法 97 38 65 49 76 a [ 0 ] a [ 1 ] a [ 2 ] a [ 3 ] a [ 4 ] 1 i 4 4.4.3 应用举例 1. 选择排序法 97 38 65 49 76 a [ 0 ] a [ 1 ] a [ 2 ] a [ 3 ] a [ 4 ] 1 i 4 j t for ( i = 0 ; i < n-1 ; i ++ ) // n = 4 { t = i ; for ( j = i + 1 ; j < n ; j ++ ) if ( a[ j ] > a [ t ] ) t = j ; 把 a [ t ] 与 a [ i ] 交换 } 76 a [ 1 ] a [ 4 ] 38

1. 选择排序法 97 76 65 49 38 a [ 0 ] a [ 1 ] a [ 2 ] a [ 3 ] a [ 4 ] 1 i 5 4.4.3 应用举例 1. 选择排序法 97 76 65 49 38 a [ 0 ] a [ 1 ] a [ 2 ] a [ 3 ] a [ 4 ] 1 i 5 j 4 t for ( i = 0 ; i < n-1 ; i ++ ) // n = 4 { t = i ; for ( j = i + 1 ; j < n ; j ++ ) if ( a[ j ] > a [ t ] ) t = j ; 把 a [ t ] 与 a [ i ] 交换 } 2 3 2 65 a [ 3 ] < a [ 2 ] 49 a [ 3 ] : a [ 2 ]

1. 选择排序法 for ( i = 0 ; i < n-1 ; i ++ ) // n = 4 { t = i ; 4.4.3 应用举例 1. 选择排序法 for ( i = 0 ; i < n-1 ; i ++ ) // n = 4 { t = i ; for ( j = i + 1 ; j < n ; j ++ ) if ( a[ j ] > a [ t ] ) t = j ; 把 a [ t ] 与 a [ i ] 交换 } 97 76 65 49 38 a [ 0 ] a [ 1 ] a [ 2 ] a [ 3 ] a [ 4 ] 2 i 3 j t 4 65 a [ 4 ] < a [ 2 ] a [ 4 ] : a [ 2 ] 38

1. 选择排序法 97 76 65 49 38 a [ 0 ] a [ 1 ] a [ 2 ] a [ 3 ] a [ 4 ] 2 i 4 4.4.3 应用举例 1. 选择排序法 97 76 65 49 38 a [ 0 ] a [ 1 ] a [ 2 ] a [ 3 ] a [ 4 ] 2 i 4 j t for ( i = 0 ; i < n-1 ; i ++ ) // n = 4 { t = i ; for ( j = i + 1 ; j < n ; j ++ ) if ( a[ j ] > a [ t ] ) t = j ; 把 a [ t ] 与 a [ i ] 交换 } 65 a [ 2 ] a [ 2 ]

1. 选择排序法 97 76 65 49 38 a [ 0 ] a [ 1 ] a [ 2 ] a [ 3 ] a [ 4 ] 2 i 5 4.4.3 应用举例 1. 选择排序法 97 76 65 49 38 a [ 0 ] a [ 1 ] a [ 2 ] a [ 3 ] a [ 4 ] 2 i 5 j t for ( i = 0 ; i < n-1 ; i ++ ) // n = 4 { t = i ; for ( j = i + 1 ; j < n ; j ++ ) if ( a[ j ] > a [ t ] ) t = j ; 把 a [ t ] 与 a [ i ] 交换 } 3 4 3 a [ 4 ] < a [ 3 ] 49 a [ 4 ] : a [ 3 ] 38

1. 选择排序法 97 76 65 49 38 a [ 0 ] a [ 1 ] a [ 2 ] a [ 3 ] a [ 4 ] 3 i 5 4.4.3 应用举例 1. 选择排序法 97 76 65 49 38 a [ 0 ] a [ 1 ] a [ 2 ] a [ 3 ] a [ 4 ] 3 i 5 j t for ( i = 0 ; i < n-1 ; i ++ ) // n = 4 { t = i ; for ( j = i + 1 ; j < n ; j ++ ) if ( a[ j ] > a [ t ] ) t = j ; 把 a [ t ] 与 a [ i ] 交换 } a [ 3 ] a [ 3 ] 49

1. 选择排序法 排序结束 97 76 65 49 38 a [ 0 ] a [ 1 ] a [ 2 ] a [ 3 ] a [ 4 ] 4 4.4.3 应用举例 1. 选择排序法 97 76 65 49 38 a [ 0 ] a [ 1 ] a [ 2 ] a [ 3 ] a [ 4 ] 4 i 5 j 3 t for ( i = 0 ; i < n-1 ; i ++ ) // n = 4 { t = i ; for ( j = i + 1 ; j < n ; j ++ ) if ( a[ j ] > a [ t ] ) t = j ; 把 a [ t ] 与 a [ i ] 交换 } 排序结束

1. 选择排序法 // 例4-14 #include<iostream> #include<cstdlib> 4.4.3 应用举例 // 例4-14 #include<iostream> #include<cstdlib> #include<ctime> using namespace std ; void sort ( int [] , int ) ; int main() { int i, a [10] ; srand ( int( time( 0 ) ) ) ; //调用种子函数 for ( i = 0 ; i < 10 ; i ++ ) a[i] = rand() % 100 ; //用随机函数初始化数组 for ( i = 0 ; i < 10 ; i ++ ) cout << a[ i ] << " " ; //输出原始序列 cout << endl ; sort ( a , 10 ) ; //调用排序函数 cout << "Order1:" << endl ; for ( i = 0 ; i < 10 ; i ++ ) cout << a[ i ] << " " ; //输出排序后序列 }

1. 选择排序法 // 例4-14 #include<iostream> #include<cstdlib> 4.4.3 应用举例 // 例4-14 #include<iostream> #include<cstdlib> #include<ctime> using namespace std ; void sort ( int [] , int ) ; int main() { int i, a [10] ; srand ( int( time( 0 ) ) ) ; //调用种子函数 for ( i = 0 ; i < 10 ; i ++ ) a[i] = rand() % 100 ; //用随机函数初始化数组 for ( i = 0 ; i < 10 ; i ++ ) cout << a[ i ] << " " ; //输出原始序列 cout << endl ; sort ( a , 10 ) ; //调用排序函数 cout << "Order1:" << endl ; for ( i = 0 ; i < 10 ; i ++ ) cout << a[ i ] << " " ; //输出排序后序列 } 时间函数

1. 选择排序法 // 例4-14 #include<iostream> #include<cstdlib> 4.4.3 应用举例 // 例4-14 #include<iostream> #include<cstdlib> #include<ctime> using namespace std ; void sort ( int [] , int ) ; int main() { int i, a [10] ; srand ( int( time( 0 ) ) ) ; //调用种子函数 for ( i = 0 ; i < 10 ; i ++ ) a[i] = rand() % 100 ; //用随机函数初始化数组 for ( i = 0 ; i < 10 ; i ++ ) cout << a[ i ] << " " ; //输出原始序列 cout << endl ; sort ( a , 10 ) ; //调用排序函数 cout << "Order1:" << endl ; for ( i = 0 ; i < 10 ; i ++ ) cout << a[ i ] << " " ; //输出排序后序列 } 种子函数

1. 选择排序法 // 例4-14 #include<iostream> #include<cstdlib> 4.4.3 应用举例 // 例4-14 #include<iostream> #include<cstdlib> #include<ctime> using namespace std ; void sort ( int [] , int ) ; int main() { int i, a [10] ; srand ( int( time( 0 ) ) ) ; //调用种子函数 for ( i = 0 ; i < 10 ; i ++ ) a[i] = rand() % 100 ; //用随机函数初始化数组 for ( i = 0 ; i < 10 ; i ++ ) cout << a[ i ] << " " ; //输出原始序列 cout << endl ; sort ( a , 10 ) ; //调用排序函数 cout << "Order1:" << endl ; for ( i = 0 ; i < 10 ; i ++ ) cout << a[ i ] << " " ; //输出排序后序列 } 随机函数

1. 选择排序法 // 例4-14 #include<iostream> #include<cstdlib> 4.4.3 应用举例 // 例4-14 #include<iostream> #include<cstdlib> #include<ctime> using namespace std ; void sort ( int [] , int ) ; int main() { int i, a [10] ; srand ( int( time( 0 ) ) ) ; //调用种子函数 for ( i = 0 ; i < 10 ; i ++ ) a[i] = rand() % 100 ; //用随机函数初始化数组 for ( i = 0 ; i < 10 ; i ++ ) cout << a[ i ] << " " ; //输出原始序列 cout << endl ; sort ( a , 10 ) ; //调用排序函数 cout << "Order1:" << endl ; for ( i = 0 ; i < 10 ; i ++ ) cout << a[ i ] << " " ; //输出排序后序列 } 调用自定义函数

1. 选择排序法 // sort void sort ( int x[] , int n ) { int max , t ; 4.4.3 应用举例 // sort void sort ( int x[] , int n ) { int max , t ; for ( int i = 0 ; i < n-1 ; i ++ ) //对数组排序 { t = i ; for ( int j = i + 1 ; j < n ; j ++ ) //寻找最大元素 if ( x [ j ] > x [ t ] ) t = j ; if ( t != i ) { max = x [ i ] ; //交换数组元素 x [ i ] = x [ t ] ; x [ t ] = max ; } return ; 升序用 < 比较

随机函数 线性同余法产生伪随机数序列公式： rk = ( M * rk-1 + K ) Mod A 4.4.3 应用举例 随机函数 线性同余法产生伪随机数序列公式： rk = ( M * rk-1 + K ) Mod A 例： rk = （ 25173 * rk-1 + 13849 ）% 32767 可以产生32767个各不相同的整型随机数 问题： 若r0 已知，则所有rk 可知 解决： 修改公式 r = ( M * N + K ) Mod A 其中：N称为种子值，由函数srand () 返回。

随机函数 Visual C++的标准库（stdlib.h）提供两个用于产生随机数的函数： rand() 4.4.3 应用举例 随机函数 Visual C++的标准库（stdlib.h）提供两个用于产生随机数的函数： rand() 随机函数。返回0～32767的随机值。该函数没有参数 srand ( number ) 种子函数。要求一个无符号整型参数置随机数生成器的启动值 为使种子值可变，用系统时间做srand函数的参数： time() 时间函数，在time.h定义。用0作参数时，返回系统当前时间

2. 冒泡排序法 —— 采用相邻元素比较的方法 示例：对数组元素进行升序排列 b [ 0 ] 49 38 65 97 76 13 27 52 4.4.3 应用举例 2. 冒泡排序法 —— 采用相邻元素比较的方法 示例：对数组元素进行升序排列 b [ 0 ] 49 38 65 97 76 13 27 52 b[0] b[1] b[2] b[3] b[4] b[5] b[6] b[7] 49 b [ 0 ] > b [ 1 ] 38 b [ 1 ]

2. 冒泡排序法 —— 采用相邻元素比较的方法 示例：对数组元素进行升序排列 b [ 0 ] 49 38 65 97 76 13 27 52 4.4.3 应用举例 2. 冒泡排序法 —— 采用相邻元素比较的方法 示例：对数组元素进行升序排列 b [ 0 ] 49 38 65 97 76 13 27 52 b[0] b[1] b[2] b[3] b[4] b[5] b[6] b[7] 38 b [ 0 ] > b [ 1 ] 49 b [ 1 ]

2. 冒泡排序法 —— 采用相邻元素比较的方法 示例：对数组元素进行升序排列 38 49 65 97 76 13 27 52 b[0] 4.4.3 应用举例 2. 冒泡排序法 —— 采用相邻元素比较的方法 示例：对数组元素进行升序排列 38 49 65 97 76 13 27 52 b[0] b[1] b[2] b[3] b[4] b[5] b[6] b[7] 49 b [ 1 ] < b [ 2 ] 65

2. 冒泡排序法 —— 采用相邻元素比较的方法 示例：对数组元素进行升序排列 38 49 65 97 76 13 27 52 b[0] 4.4.3 应用举例 2. 冒泡排序法 —— 采用相邻元素比较的方法 示例：对数组元素进行升序排列 38 49 65 97 76 13 27 52 b[0] b[1] b[2] b[3] b[4] b[5] b[6] b[7] 65 b [ 2 ] < b [ 3 ] 97

2. 冒泡排序法 —— 采用相邻元素比较的方法 示例：对数组元素进行升序排列 38 49 65 97 76 13 27 52 b[0] 4.4.3 应用举例 2. 冒泡排序法 —— 采用相邻元素比较的方法 示例：对数组元素进行升序排列 38 49 65 97 76 13 27 52 b[0] b[1] b[2] b[3] b[4] b[5] b[6] b[7] b [ 3 ] 97 b [ 3 ] > b [ 4 ] 76 b [ 4 ]

2. 冒泡排序法 —— 采用相邻元素比较的方法 示例：对数组元素进行升序排列 38 49 65 97 76 13 27 52 b[0] 4.4.3 应用举例 2. 冒泡排序法 —— 采用相邻元素比较的方法 示例：对数组元素进行升序排列 38 49 65 97 76 13 27 52 b[0] b[1] b[2] b[3] b[4] b[5] b[6] b[7] b [ 3 ] 76 b [ 3 ] > b [ 4 ] 97 b [ 4 ]

2. 冒泡排序法 —— 采用相邻元素比较的方法 示例：对数组元素进行升序排列 38 49 65 76 97 13 27 52 b[0] 4.4.3 应用举例 2. 冒泡排序法 —— 采用相邻元素比较的方法 示例：对数组元素进行升序排列 38 49 65 76 97 13 27 52 b[0] b[1] b[2] b[3] b[4] b[5] b[6] b[7] b [ 4 ] 97 b [ 4 ] > b [ 5 ] 13 b [ 5 ]

2. 冒泡排序法 —— 采用相邻元素比较的方法 示例：对数组元素进行升序排列 38 49 65 76 97 13 27 52 b[0] 4.4.3 应用举例 2. 冒泡排序法 —— 采用相邻元素比较的方法 示例：对数组元素进行升序排列 38 49 65 76 97 13 27 52 b[0] b[1] b[2] b[3] b[4] b[5] b[6] b[7] b [ 4 ] 13 b [ 4 ] > b [ 5 ] 97 b [ 5 ]

2. 冒泡排序法 —— 采用相邻元素比较的方法 示例：对数组元素进行升序排列 38 49 65 76 13 97 27 52 b[0] 4.4.3 应用举例 2. 冒泡排序法 —— 采用相邻元素比较的方法 示例：对数组元素进行升序排列 38 49 65 76 13 97 27 52 b[0] b[1] b[2] b[3] b[4] b[5] b[6] b[7] b [ 5 ] 97 b [ 5 ] > b [ 6 ] 27 b [ 6 ]

2. 冒泡排序法 —— 采用相邻元素比较的方法 示例：对数组元素进行升序排列 38 49 65 76 13 97 27 52 b[0] 4.4.3 应用举例 2. 冒泡排序法 —— 采用相邻元素比较的方法 示例：对数组元素进行升序排列 38 49 65 76 13 97 27 52 b[0] b[1] b[2] b[3] b[4] b[5] b[6] b[7] b [ 5 ] 97 b [ 5 ] > b [ 6 ] 27 b [ 6 ]

2. 冒泡排序法 —— 采用相邻元素比较的方法 示例：对数组元素进行升序排列 38 49 65 76 13 27 97 52 b[0] 4.4.3 应用举例 2. 冒泡排序法 —— 采用相邻元素比较的方法 示例：对数组元素进行升序排列 38 49 65 76 13 27 97 52 b[0] b[1] b[2] b[3] b[4] b[5] b[6] b[7] b [ 6 ] 97 b [ 6 ] > b [ 7 ] 52 b [ 7 ]

2. 冒泡排序法 —— 采用相邻元素比较的方法 示例：对数组元素进行升序排列 38 49 65 76 13 27 97 52 b[0] 4.4.3 应用举例 2. 冒泡排序法 —— 采用相邻元素比较的方法 示例：对数组元素进行升序排列 38 49 65 76 13 27 97 52 b[0] b[1] b[2] b[3] b[4] b[5] b[6] b[7] b [ 6 ] 52 b [ 6 ] > b [ 7 ] 97 b [ 7 ]

2. 冒泡排序法 —— 采用相邻元素比较的方法 示例：对数组元素进行升序排列 38 49 65 76 13 27 52 97 b[0] 4.4.3 应用举例 2. 冒泡排序法 —— 采用相邻元素比较的方法 示例：对数组元素进行升序排列 38 49 65 76 13 27 52 97 b[0] b[1] b[2] b[3] b[4] b[5] b[6] b[7]

2. 冒泡排序法 —— 采用相邻元素比较的方法 示例：对数组元素进行升序排列 38 49 65 76 13 27 52 97 b[0] 4.4.3 应用举例 2. 冒泡排序法 —— 采用相邻元素比较的方法 示例：对数组元素进行升序排列 38 49 65 76 13 27 52 97 b[0] b[1] b[2] b[3] b[4] b[5] b[6] b[7] 38 49 65 76 13 27 52 97 38 b [ 0 ] < b [ 1 ] 49

2. 冒泡排序法 —— 采用相邻元素比较的方法 示例：对数组元素进行升序排列 38 49 65 76 13 27 52 97 b[0] 4.4.3 应用举例 2. 冒泡排序法 —— 采用相邻元素比较的方法 示例：对数组元素进行升序排列 38 49 65 76 13 27 52 97 b[0] b[1] b[2] b[3] b[4] b[5] b[6] b[7] 38 49 65 76 13 27 52 97 49 b [ 1 ] < b [ 2 ] 65

2. 冒泡排序法 —— 采用相邻元素比较的方法 示例：对数组元素进行升序排列 38 49 65 76 13 27 52 97 b[0] 4.4.3 应用举例 2. 冒泡排序法 —— 采用相邻元素比较的方法 示例：对数组元素进行升序排列 38 49 65 76 13 27 52 97 b[0] b[1] b[2] b[3] b[4] b[5] b[6] b[7] 38 49 65 76 13 27 52 97 65 b [ 2 ] < b [ 3 ] 76

2. 冒泡排序法 —— 采用相邻元素比较的方法 示例：对数组元素进行升序排列 38 49 65 76 13 27 52 97 b[0] 4.4.3 应用举例 2. 冒泡排序法 —— 采用相邻元素比较的方法 示例：对数组元素进行升序排列 38 49 65 76 13 27 52 97 b[0] b[1] b[2] b[3] b[4] b[5] b[6] b[7] 38 49 65 76 13 27 52 97 b [ 3 ] 76 b [ 3 ] > b [ 4 ] 13 b [ 4 ]

2. 冒泡排序法 —— 采用相邻元素比较的方法 示例：对数组元素进行升序排列 38 49 65 76 13 27 52 97 b[0] 4.4.3 应用举例 2. 冒泡排序法 —— 采用相邻元素比较的方法 示例：对数组元素进行升序排列 38 49 65 76 13 27 52 97 b[0] b[1] b[2] b[3] b[4] b[5] b[6] b[7] 38 49 65 76 13 27 52 97 b [ 3 ] 13 b [ 3 ] > b [ 4 ] 76 b [ 4 ]

2. 冒泡排序法 —— 采用相邻元素比较的方法 示例：对数组元素进行升序排列 38 49 65 76 13 27 52 97 b[0] 4.4.3 应用举例 2. 冒泡排序法 —— 采用相邻元素比较的方法 示例：对数组元素进行升序排列 38 49 65 76 13 27 52 97 b[0] b[1] b[2] b[3] b[4] b[5] b[6] b[7] 38 49 65 13 76 27 52 97 b [ 4 ] 76 b [ 4 ] > b [ 5 ] 27 b [ 5 ]

2. 冒泡排序法 —— 采用相邻元素比较的方法 示例：对数组元素进行升序排列 38 49 65 76 13 27 52 97 b[0] 4.4.3 应用举例 2. 冒泡排序法 —— 采用相邻元素比较的方法 示例：对数组元素进行升序排列 38 49 65 76 13 27 52 97 b[0] b[1] b[2] b[3] b[4] b[5] b[6] b[7] 38 49 65 13 76 27 52 97 b [ 4 ] 27 b [ 4 ] > b [ 5 ] 76 b [ 5 ]

2. 冒泡排序法 —— 采用相邻元素比较的方法 示例：对数组元素进行升序排列 38 49 65 76 13 27 52 97 b[0] 4.4.3 应用举例 2. 冒泡排序法 —— 采用相邻元素比较的方法 示例：对数组元素进行升序排列 38 49 65 76 13 27 52 97 b[0] b[1] b[2] b[3] b[4] b[5] b[6] b[7] 38 49 65 13 b [ 5 ] 27 76 76 b [ 5 ] > b [ 6 ] 52 52 b [ 6 ] 97

2. 冒泡排序法 —— 采用相邻元素比较的方法 示例：对数组元素进行升序排列 38 49 65 76 13 27 52 97 b[0] 4.4.3 应用举例 2. 冒泡排序法 —— 采用相邻元素比较的方法 示例：对数组元素进行升序排列 38 49 65 76 13 27 52 97 b[0] b[1] b[2] b[3] b[4] b[5] b[6] b[7] 38 49 65 13 b [ 5 ] 27 52 76 b [ 5 ] > b [ 6 ] 76 52 b [ 6 ] 97

2. 冒泡排序法 —— 采用相邻元素比较的方法 示例：对数组元素进行升序排列 38 49 65 76 13 27 52 97 b[0] 4.4.3 应用举例 2. 冒泡排序法 —— 采用相邻元素比较的方法 示例：对数组元素进行升序排列 38 49 65 76 13 27 52 97 b[0] b[1] b[2] b[3] b[4] b[5] b[6] b[7] 38 49 65 13 27 52 76 97

2. 冒泡排序法 —— 采用相邻元素比较的方法 不需进行数据交换 示例：对数组元素进行升序排列 49 38 65 97 76 13 27 4.4.3 应用举例 2. 冒泡排序法 —— 采用相邻元素比较的方法 不需进行数据交换 示例：对数组元素进行升序排列 49 38 65 97 76 13 27 52 38 49 65 76 13 27 52 97 b[0] b[1] b[2] b[3] b[4] b[5] b[6] b[7] 38 38 49 13 27 52 65 76 97 38 13 27 49 52 65 76 97 13 27 38 49 52 65 76 97 13 27 38 49 52 65 76 97 13 27 38 49 52 65 76 97 49 65 13 27 52 76 97

2. 冒泡排序法 —— 采用相邻元素比较的方法 // bubble void bubble ( int a[] , int size ) 4.4.3 应用举例 2. 冒泡排序法 —— 采用相邻元素比较的方法 // bubble void bubble ( int a[] , int size ) { int i , temp , work ; for ( int pass = 1 ; pass < size ; pass ++ ) //对数组排序 { work = 1 ; for ( i = 0 ; i < size-pass ; i ++ ) if ( a [ i ] > a [ i + 1 ] ) //相邻元素比较 { temp = a [ i ] ; a [ i ] = a [ i + 1 ] ; a [ i + 1 ] = temp ; work = 0 ; } if ( work ) break ; 辅助工作变量 监控相邻元素是否被交换

3. 矩阵相乘 设 A 为 m  n 的矩阵，B 为 n  l 的矩阵，求矩阵相乘 C = A  B 则 C 阵为 m  l 的矩阵 4.4.3 应用举例 3. 矩阵相乘 设 A 为 m  n 的矩阵，B 为 n  l 的矩阵，求矩阵相乘 C = A  B 则 C 阵为 m  l 的矩阵

i j k A = C  B for ( int i = 0 ; i < cm ; i + + ) 4.4.3 应用举例 for ( int i = 0 ; i < cm ; i + + ) for ( int j = 0 ; j < cl ; j + + ) { for ( int k = 0 ; k < cn ; k + + ) c [ i ] [ j ] + = a [ i ] [ k ] * b[ k ] [ j ] } cm = 3 cl = 3 cn = 2 i j k c [ 0 ] [ 0 ] = 5 * 12 5 7 8 3 4 A 5 12 = C 12 3 4 2 6 7  B

i j k A  B = C for ( int i = 0 ; i < cm ; i + + ) 4.4.3 应用举例 for ( int i = 0 ; i < cm ; i + + ) for ( int j = 0 ; j < cl ; j + + ) { for ( int k = 0 ; k < cn ; k + + ) c [ i ] [ j ] + = a [ i ] [ k ] * b[ k ] [ j ] } cm = 3 cl = 3 cn = 2 i j k 1 c [ 0 ] [ 0 ] = 5 * 12 + 7 * 4 5 7 8 3 4 12 2 6 A  B = C 7 4 88

i j k A = C  B for ( int i = 0 ; i < cm ; i + + ) 4.4.3 应用举例 for ( int i = 0 ; i < cm ; i + + ) for ( int j = 0 ; j < cl ; j + + ) { for ( int k = 0 ; k < cn ; k + + ) c [ i ] [ j ] + = a [ i ] [ k ] * b[ k ] [ j ] } cm = 3 cl = 3 cn = 2 i j k 1 c [ 0 ] [ 1 ] = 5 * 3 5 7 8 3 4 A 5 = C 88 12 3 4 2 6 7  B 3

i j k A  B = C for ( int i = 0 ; i < cm ; i + + ) 4.4.3 应用举例 for ( int i = 0 ; i < cm ; i + + ) for ( int j = 0 ; j < cl ; j + + ) { for ( int k = 0 ; k < cn ; k + + ) c [ i ] [ j ] + = a [ i ] [ k ] * b[ k ] [ j ] } cm = 3 cl = 3 cn = 2 i j k 1 1 c [ 0 ] [ 1 ] = 5 * 3 + 7 * 2 5 7 8 3 4 12 2 6 A  B = C 7 88 29 2

i j k A = C  B for ( int i = 0 ; i < cm ; i + + ) 4.4.3 应用举例 for ( int i = 0 ; i < cm ; i + + ) for ( int j = 0 ; j < cl ; j + + ) { for ( int k = 0 ; k < cn ; k + + ) c [ i ] [ j ] + = a [ i ] [ k ] * b[ k ] [ j ] } cm = 3 cl = 3 cn = 2 i j k 2 c [ 0 ] [ 2 ] = 5 * 6 5 7 8 3 4 A 5 = C 88 29 12 3 4 2 6 7  B 6

i j k A  B = C for ( int i = 0 ; i < cm ; i + + ) 4.4.3 应用举例 for ( int i = 0 ; i < cm ; i + + ) for ( int j = 0 ; j < cl ; j + + ) { for ( int k = 0 ; k < cn ; k + + ) c [ i ] [ j ] + = a [ i ] [ k ] * b[ k ] [ j ] } cm = 3 cl = 3 cn = 2 i j k 2 1 c [ 0 ] [ 2 ] = 5 * 6 + 7 * 7 5 7 8 3 4 12 2 6 A  B = C 7 88 29 79 7

i j k A = C  B for ( int i = 0 ; i < cm ; i + + ) 4.4.3 应用举例 for ( int i = 0 ; i < cm ; i + + ) for ( int j = 0 ; j < cl ; j + + ) { for ( int k = 0 ; k < cn ; k + + ) c [ i ] [ j ] + = a [ i ] [ k ] * b[ k ] [ j ] } cm = 3 cl = 3 cn = 2 i 1 j k c [ 1 ] [ 0 ] = 8 * 12 5 7 8 3 4 A = C 88 29 79 12 3 4 2 6 7  B 12 8

i j k A  B = C for ( int i = 0 ; i < cm ; i + + ) 4.4.3 应用举例 for ( int i = 0 ; i < cm ; i + + ) for ( int j = 0 ; j < cl ; j + + ) { for ( int k = 0 ; k < cn ; k + + ) c [ i ] [ j ] + = a [ i ] [ k ] * b[ k ] [ j ] } cm = 3 cl = 3 cn = 2 i j k 1 1 c [ 1 ] [ 0 ] = 8 * 12 + 3 * 4 5 7 8 3 4 12 2 6 A  B = C 88 29 79 3 108 4

i j k A = C  B for ( int i = 0 ; i < cm ; i + + ) 4.4.3 应用举例 for ( int i = 0 ; i < cm ; i + + ) for ( int j = 0 ; j < cl ; j + + ) { for ( int k = 0 ; k < cn ; k + + ) c [ i ] [ j ] + = a [ i ] [ k ] * b[ k ] [ j ] } cm = 3 cl = 3 cn = 2 i j k 1 1 c [ 1 ] [ 1 ] = 8 * 3 5 7 8 3 4 A = C 88 29 79 12 3 4 2 6 7  B 3 8 108

i j k A  B = C for ( int i = 0 ; i < cm ; i + + ) 4.4.3 应用举例 for ( int i = 0 ; i < cm ; i + + ) for ( int j = 0 ; j < cl ; j + + ) { for ( int k = 0 ; k < cn ; k + + ) c [ i ] [ j ] + = a [ i ] [ k ] * b[ k ] [ j ] } cm = 3 cl = 3 cn = 2 i j k 1 1 1 c [ 1 ] [ 1 ] = 8 * 3 + 3 * 2 5 7 8 3 4 12 2 6 A  B = C 88 29 79 3 108 30 2

i j k A = C  B for ( int i = 0 ; i < cm ; i + + ) 4.4.3 应用举例 for ( int i = 0 ; i < cm ; i + + ) for ( int j = 0 ; j < cl ; j + + ) { for ( int k = 0 ; k < cn ; k + + ) c [ i ] [ j ] + = a [ i ] [ k ] * b[ k ] [ j ] } cm = 3 cl = 3 cn = 2 i j k 1 2 c [ 1 ] [ 2 ] = 8 * 6 5 7 8 3 4 A = C 88 29 79 12 3 4 2 6 7  B 6 8 108 30

i j k A  B = C for ( int i = 0 ; i < cm ; i + + ) 4.4.3 应用举例 for ( int i = 0 ; i < cm ; i + + ) for ( int j = 0 ; j < cl ; j + + ) { for ( int k = 0 ; k < cn ; k + + ) c [ i ] [ j ] + = a [ i ] [ k ] * b[ k ] [ j ] } cm = 3 cl = 3 cn = 2 i j k 1 2 1 c [ 1 ] [ 2 ] = 8 * 6 + 3 * 7 5 7 8 3 4 12 2 6 A  B = C 88 29 79 3 108 30 69 7

i j k A = C  B for ( int i = 0 ; i < cm ; i + + ) 4.4.3 应用举例 for ( int i = 0 ; i < cm ; i + + ) for ( int j = 0 ; j < cl ; j + + ) { for ( int k = 0 ; k < cn ; k + + ) c [ i ] [ j ] + = a [ i ] [ k ] * b[ k ] [ j ] } cm = 3 cl = 3 cn = 2 i j k 2 c [ 2 ] [ 0 ] = 7 * 12 5 7 8 3 4 A = C 88 29 79 12 3 4 2 6 7  B 12 108 30 69 7

i j k A  B = C for ( int i = 0 ; i < cm ; i + + ) 4.4.3 应用举例 for ( int i = 0 ; i < cm ; i + + ) for ( int j = 0 ; j < cl ; j + + ) { for ( int k = 0 ; k < cn ; k + + ) c [ i ] [ j ] + = a [ i ] [ k ] * b[ k ] [ j ] } cm = 3 cl = 3 cn = 2 i j k 2 1 c [ 2 ] [ 0 ] = 7 * 12 + 4 * 4 5 7 8 3 4 12 2 6 A  B = C 88 29 79 108 30 69 4 4 100

i j k A = C  B for ( int i = 0 ; i < cm ; i + + ) 4.4.3 应用举例 for ( int i = 0 ; i < cm ; i + + ) for ( int j = 0 ; j < cl ; j + + ) { for ( int k = 0 ; k < cn ; k + + ) c [ i ] [ j ] + = a [ i ] [ k ] * b[ k ] [ j ] } cm = 3 cl = 3 cn = 2 i j k 2 1 c [ 2 ] [ 1 ] = 7 * 3 5 7 8 3 4 A = C 88 29 79 12 3 4 2 6 7  B 3 108 30 69 7 100

i j k A  B = C for ( int i = 0 ; i < cm ; i + + ) 4.4.3 应用举例 for ( int i = 0 ; i < cm ; i + + ) for ( int j = 0 ; j < cl ; j + + ) { for ( int k = 0 ; k < cn ; k + + ) c [ i ] [ j ] + = a [ i ] [ k ] * b[ k ] [ j ] } cm = 3 cl = 3 cn = 2 i j k 2 1 1 c [ 2 ] [ 1 ] = 7 * 3 + 4 * 2 5 7 8 3 4 12 2 6 A  B = C 88 29 79 108 30 69 2 4 100 29

i j k A = C  B for ( int i = 0 ; i < cm ; i + + ) 4.4.3 应用举例 for ( int i = 0 ; i < cm ; i + + ) for ( int j = 0 ; j < cl ; j + + ) { for ( int k = 0 ; k < cn ; k + + ) c [ i ] [ j ] + = a [ i ] [ k ] * b[ k ] [ j ] } cm = 3 cl = 3 cn = 2 i j k 2 2 c [ 2 ] [ 2 ] = 7 * 6 5 7 8 3 4 A = C 88 29 79 12 3 4 2 6 7  B 6 108 30 69 7 100 29

i j k A  B = C for ( int i = 0 ; i < cm ; i + + ) 4.4.3 应用举例 for ( int i = 0 ; i < cm ; i + + ) for ( int j = 0 ; j < cl ; j + + ) { for ( int k = 0 ; k < cn ; k + + ) c [ i ] [ j ] + = a [ i ] [ k ] * b[ k ] [ j ] } cm = 3 cl = 3 cn = 2 i j k 2 2 1 c [ 2 ] [ 2 ] = 7 * 6 + 4 * 7 5 7 8 3 4 12 2 6 A  B = C 88 29 79 108 30 69 7 4 100 29 70

#include<iostream> //例4-15 #include<iomanip> using namespace std ; const int m = 4, p = 3, n = 2 ; int a[m][p] , b[p][n] , c[m][n] ; bool multimatrix ( const int a[m][p] , int arow , int acol , const int b[p][n] , int brow , int bcol , int c[m][n] , int crow , int ccol ) ; int main() { int i , j ; cout << "Please input A:\n" ; //输入矩阵A元素 for ( i = 0 ; i < m ; i ++ ) for ( j = 0 ; j < p ; j ++ ) cin >> a[i][j] ; cout << "\nPlease input B:\n" ; //输入矩阵B元素 for ( i = 0 ; i < p ; i ++ ) for( j = 0; j<n; j++ ) cin >> b[i][j] ; if ( !multimatrix ( a , m , p , b , p , n , c , m , n ) ) //调用函数计算矩阵乘积 { cout << "illegal matrix multiply.\n" ; return ; } for ( i = 0 ; i < m ; i ++ ) //输出结果矩阵C { for ( j = 0 ; j < n ; j ++ ) cout << setw( 5 ) << c[i][j] ; cout << endl ; 4.4.3 应用举例

#include<iostream> //例4-15 #include<iomanip> using namespace std ; const int m = 4, p = 3, n = 2 ; int a[m][p] , b[p][n] , c[m][n] ; bool multimatrix ( const int a[m][p] , int arow , int acol , const int b[p][n] , int brow , int bcol , int c[m][n] , int crow , int ccol ) ; int main() { int i , j ; cout << "Please input A:\n" ; //输入矩阵A元素 for ( i = 0 ; i < m ; i ++ ) for ( j = 0 ; j < p ; j ++ ) cin >> a[i][j] ; cout << "\nPlease input B:\n" ; //输入矩阵B元素 for ( i = 0 ; i < p ; i ++ ) for( j = 0; j<n; j++ ) cin >> b[i][j] ; if ( !multimatrix ( a , m , p , b , p , n , c , m , n ) ) //调用函数计算矩阵乘积 { cout << "illegal matrix multiply.\n" ; return ; } for ( i = 0 ; i < m ; i ++ ) //输出结果矩阵C { for ( j = 0 ; j < n ; j ++ ) cout << setw( 5 ) << c[i][j] ; cout << endl ; 4.4.3 应用举例 数据声明 它们是全局量

#include<iostream> //例4-15 #include<iomanip> using namespace std ; const int m = 4, p = 3, n = 2 ; int a[m][p] , b[p][n] , c[m][n] ; bool multimatrix ( const int a[m][p] , int arow , int acol , const int b[p][n] , int brow , int bcol , int c[m][n] , int crow , int ccol ) ; int main() { int i , j ; cout << "Please input A:\n" ; //输入矩阵A元素 for ( i = 0 ; i < m ; i ++ ) for ( j = 0 ; j < p ; j ++ ) cin >> a[i][j] ; cout << "\nPlease input B:\n" ; //输入矩阵B元素 for ( i = 0 ; i < p ; i ++ ) for( j = 0; j<n; j++ ) cin >> b[i][j] ; if ( !multimatrix ( a , m , p , b , p , n , c , m , n ) ) //调用函数计算矩阵乘积 { cout << "illegal matrix multiply.\n" ; return ; } for ( i = 0 ; i < m ; i ++ ) //输出结果矩阵C { for ( j = 0 ; j < n ; j ++ ) cout << setw( 5 ) << c[i][j] ; cout << endl ; 4.4.3 应用举例 矩阵相乘的 函数原型

#include<iostream> //例4-15 #include<iomanip> using namespace std ; const int m = 4, p = 3, n = 2 ; int a[m][p] , b[p][n] , c[m][n] ; bool multimatrix ( const int a[m][p] , int arow , int acol , const int b[p][n] , int brow , int bcol , int c[m][n] , int crow , int ccol ) ; int main() { int i , j ; cout << "Please input A:\n" ; //输入矩阵A元素 for ( i = 0 ; i < m ; i ++ ) for ( j = 0 ; j < p ; j ++ ) cin >> a[i][j] ; cout << "\nPlease input B:\n" ; //输入矩阵B元素 for ( i = 0 ; i < p ; i ++ ) for( j = 0; j<n; j++ ) cin >> b[i][j] ; if ( !multimatrix ( a , m , p , b , p , n , c , m , n ) ) //调用函数计算矩阵乘积 { cout << "illegal matrix multiply.\n" ; return ; } for ( i = 0 ; i < m ; i ++ ) //输出结果矩阵C { for ( j = 0 ; j < n ; j ++ ) cout << setw( 5 ) << c[i][j] ; cout << endl ; 4.4.3 应用举例 被运算矩阵 约束为只读

#include<iostream> //例4-15 #include<iomanip> using namespace std ; const int m = 4, p = 3, n = 2 ; int a[m][p] , b[p][n] , c[m][n] ; bool multimatrix ( const int a[m][p] , int arow , int acol , const int b[p][n] , int brow , int bcol , int c[m][n] , int crow , int ccol ) ; int main() { int i , j ; cout << "Please input A:\n" ; //输入矩阵A元素 for ( i = 0 ; i < m ; i ++ ) for ( j = 0 ; j < p ; j ++ ) cin >> a[i][j] ; cout << "\nPlease input B:\n" ; //输入矩阵B元素 for ( i = 0 ; i < p ; i ++ ) for( j = 0; j<n; j++ ) cin >> b[i][j] ; if ( !multimatrix ( a , m , p , b , p , n , c , m , n ) ) //调用函数计算矩阵乘积 { cout << "illegal matrix multiply.\n" ; return ; } for ( i = 0 ; i < m ; i ++ ) //输出结果矩阵C { for ( j = 0 ; j < n ; j ++ ) cout << setw( 5 ) << c[i][j] ; cout << endl ; 4.4.3 应用举例 参数表 还有什么书写形式？

OK #include<iostream> //例4-15 #include<iomanip> using namespace std ; const int m = 4, p = 3, n = 2 ; int a[m][p] , b[p][n] , c[m][n] ; bool multimatrix ( const int a[m][p] , int arow , int acol , const int b[p][n] , int brow , int bcol , int c[m][n] , int crow , int ccol ) ; int main() { int i , j ; cout << "Please input A:\n" ; //输入矩阵A元素 for ( i = 0 ; i < m ; i ++ ) for ( j = 0 ; j < p ; j ++ ) cin >> a[i][j] ; cout << "\nPlease input B:\n" ; //输入矩阵B元素 for ( i = 0 ; i < p ; i ++ ) for( j = 0; j<n; j++ ) cin >> b[i][j] ; if ( !multimatrix ( a , m , p , b , p , n , c , m , n ) ) //调用函数计算矩阵乘积 { cout << "illegal matrix multiply.\n" ; return ; } for ( i = 0 ; i < m ; i ++ ) //输出结果矩阵C { for ( j = 0 ; j < n ; j ++ ) cout << setw( 5 ) << c[i][j] ; cout << endl ; 4.4.3 应用举例 OK bool multimatrix ( const int [ ][p], int , int , const int [ ][n], int , int , int [ ][n], int , int ) ;

#include<iostream> //例4-15 #include<iomanip> using namespace std ; const int m = 4, p = 3, n = 2 ; int a[m][p] , b[p][n] , c[m][n] ; bool multimatrix ( const int a[m][p] , int arow , int acol , const int b[p][n] , int brow , int bcol , int c[m][n] , int crow , int ccol ) ; int main() { int i , j ; cout << "Please input A:\n" ; //输入矩阵A元素 for ( i = 0 ; i < m ; i ++ ) for ( j = 0 ; j < p ; j ++ ) cin >> a[i][j] ; cout << "\nPlease input B:\n" ; //输入矩阵B元素 for ( i = 0 ; i < p ; i ++ ) for( j = 0; j<n; j++ ) cin >> b[i][j] ; if ( !multimatrix ( a , m , p , b , p , n , c , m , n ) ) //调用函数计算矩阵乘积 { cout << "illegal matrix multiply.\n" ; return ; } for ( i = 0 ; i < m ; i ++ ) //输出结果矩阵C { for ( j = 0 ; j < n ; j ++ ) cout << setw( 5 ) << c[i][j] ; cout << endl ; 4.4.3 应用举例 bool multimatrix ( const int [ ][ ], int , int , const int [ ][ ], int , int , int [ ][n], int , int ) ; 不能缺省 低维长度

#include<iostream> //例4-15 #include<iomanip> using namespace std ; const int m = 4, p = 3, n = 2 ; int a[m][p] , b[p][n] , c[m][n] ; bool multimatrix ( const int a[m][p] , int arow , int acol , const int b[p][n] , int brow , int bcol , int c[m][n] , int crow , int ccol ) ; int main() { int i , j ; cout << "Please input A:\n" ; //输入矩阵A元素 for ( i = 0 ; i < m ; i ++ ) for ( j = 0 ; j < p ; j ++ ) cin >> a[i][j] ; cout << "\nPlease input B:\n" ; //输入矩阵B元素 for ( i = 0 ; i < p ; i ++ ) for( j = 0; j<n; j++ ) cin >> b[i][j] ; if ( !multimatrix ( a , m , p , b , p , n , c , m , n ) ) //调用函数计算矩阵乘积 { cout << "illegal matrix multiply.\n" ; return ; } for ( i = 0 ; i < m ; i ++ ) //输出结果矩阵C { for ( j = 0 ; j < n ; j ++ ) cout << setw( 5 ) << c[i][j] ; cout << endl ; 4.4.3 应用举例 嵌套循环 输入 A 矩阵元素

#include<iostream> //例4-15 #include<iomanip> using namespace std ; const int m = 4, p = 3, n = 2 ; int a[m][p] , b[p][n] , c[m][n] ; bool multimatrix ( const int a[m][p] , int arow , int acol , const int b[p][n] , int brow , int bcol , int c[m][n] , int crow , int ccol ) ; int main() { int i , j ; cout << "Please input A:\n" ; //输入矩阵A元素 for ( i = 0 ; i < m ; i ++ ) for ( j = 0 ; j < p ; j ++ ) cin >> a[i][j] ; cout << "\nPlease input B:\n" ; //输入矩阵B元素 for ( i = 0 ; i < p ; i ++ ) for( j = 0; j<n; j++ ) cin >> b[i][j] ; if ( !multimatrix ( a , m , p , b , p , n , c , m , n ) ) //调用函数计算矩阵乘积 { cout << "illegal matrix multiply.\n" ; return ; } for ( i = 0 ; i < m ; i ++ ) //输出结果矩阵C { for ( j = 0 ; j < n ; j ++ ) cout << setw( 5 ) << c[i][j] ; cout << endl ; 4.4.3 应用举例 嵌套循环 输入 B 矩阵元素

#include<iostream> //例4-15 #include<iomanip> using namespace std ; const int m = 4, p = 3, n = 2 ; int a[m][p] , b[p][n] , c[m][n] ; bool multimatrix ( const int a[m][p] , int arow , int acol , const int b[p][n] , int brow , int bcol , int c[m][n] , int crow , int ccol ) ; int main() { int i , j ; cout << "Please input A:\n" ; //输入矩阵A元素 for ( i = 0 ; i < m ; i ++ ) for ( j = 0 ; j < p ; j ++ ) cin >> a[i][j] ; cout << "\nPlease input B:\n" ; //输入矩阵B元素 for ( i = 0 ; i < p ; i ++ ) for( j = 0; j<n; j++ ) cin >> b[i][j] ; if ( !multimatrix ( a , m , p , b , p , n , c , m , n ) ) //调用函数计算矩阵乘积 { cout << "illegal matrix multiply.\n" ; return ; } for ( i = 0 ; i < m ; i ++ ) //输出结果矩阵C { for ( j = 0 ; j < n ; j ++ ) cout << setw( 5 ) << c[i][j] ; cout << endl ; 4.4.3 应用举例 在判断表达式中 调用函数

#include<iostream> //例4-15 #include<iomanip> using namespace std ; const int m = 4, p = 3, n = 2 ; int a[m][p] , b[p][n] , c[m][n] ; bool multimatrix ( const int a[m][p] , int arow , int acol , const int b[p][n] , int brow , int bcol , int c[m][n] , int crow , int ccol ) ; int main() { int i , j ; cout << "Please input A:\n" ; //输入矩阵A元素 for ( i = 0 ; i < m ; i ++ ) for ( j = 0 ; j < p ; j ++ ) cin >> a[i][j] ; cout << "\nPlease input B:\n" ; //输入矩阵B元素 for ( i = 0 ; i < p ; i ++ ) for( j = 0; j<n; j++ ) cin >> b[i][j] ; if ( !multimatrix ( a , m , p , b , p , n , c , m , n ) ) //调用函数计算矩阵乘积 { cout << "illegal matrix multiply.\n" ; return ; } for ( i = 0 ; i < m ; i ++ ) //输出结果矩阵C { for ( j = 0 ; j < n ; j ++ ) cout << setw( 5 ) << c[i][j] ; cout << endl ; 4.4.3 应用举例 如果条件为真 结束程序

#include<iostream> //例4-15 #include<iomanip> using namespace std ; const int m = 4, p = 3, n = 2 ; int a[m][p] , b[p][n] , c[m][n] ; bool multimatrix ( const int a[m][p] , int arow , int acol , const int b[p][n] , int brow , int bcol , int c[m][n] , int crow , int ccol ) ; int main() { int i , j ; cout << "Please input A:\n" ; //输入矩阵A元素 for ( i = 0 ; i < m ; i ++ ) for ( j = 0 ; j < p ; j ++ ) cin >> a[i][j] ; cout << "\nPlease input B:\n" ; //输入矩阵B元素 for ( i = 0 ; i < p ; i ++ ) for( j = 0; j<n; j++ ) cin >> b[i][j] ; if ( !multimatrix ( a , m , p , b , p , n , c , m , n ) ) //调用函数计算矩阵乘积 { cout << "illegal matrix multiply.\n" ; return ; } for ( i = 0 ; i < m ; i ++ ) //输出结果矩阵C { for ( j = 0 ; j < n ; j ++ ) cout << setw( 5 ) << c[i][j] ; cout << endl ; 4.4.3 应用举例 如果条件为假 输出结果矩阵

bool multimatrix ( const int a[m][p] , int arow , int acol , 4.4.3 应用举例 bool multimatrix ( const int a[m][p] , int arow , int acol , const int b[p][n] , int brow , int bcol , int c[m][n] , int crow , int ccol ) { if ( acol != brow ) return false ; //判断参数合法性 if ( crow != arow ) return false ; if ( ccol != bcol ) return false ; for ( int i = 0 ; i < crow ; i ++ ) //计算矩阵相乘 for ( int j = 0 ; j < ccol ; j ++ ) { for ( int n = 0 ; n < acol ; n ++ ) c [ i ] [ j ] += a [ i ] [ n ] * b [ n ] [ j ] ; } return true ;

bool multimatrix ( const int a[m][p] , int arow , int acol , 4.4.3 应用举例 bool multimatrix ( const int a[m][p] , int arow , int acol , const int b[p][n] , int brow , int bcol , int c[m][n] , int crow , int ccol ) { if ( acol != brow ) return false ; //判断参数合法性 if ( crow != arow ) return false ; if ( ccol != bcol ) return false ; for ( int i = 0 ; i < crow ; i ++ ) //计算矩阵相乘 for ( int j = 0 ; j < ccol ; j ++ ) { for ( int n = 0 ; n < acol ; n ++ ) c [ i ] [ j ] += a [ i ] [ n ] * b [ n ] [ j ] ; } return true ; 如果行或列 参数非法返回false

bool multimatrix ( const int a[m][p] , int arow , int acol , 4.4.3 应用举例 bool multimatrix ( const int a[m][p] , int arow , int acol , const int b[p][n] , int brow , int bcol , int c[m][n] , int crow , int ccol ) { if ( acol != brow ) return false ; //判断参数合法性 if ( crow != arow ) return false ; if ( ccol != bcol ) return false ; for ( int i = 0 ; i < crow ; i ++ ) //计算矩阵相乘 for ( int j = 0 ; j < ccol ; j ++ ) { for ( int n = 0 ; n < acol ; n ++ ) c [ i ] [ j ] += a [ i ] [ n ] * b [ n ] [ j ] ; } return true ; 参数合法计算矩阵相乘 然后返回 0

bool multimatrix ( const int *a , int arow , int acol , 4.4.3 应用举例 修改函数参数： bool multimatrix ( const int *a , int arow , int acol , int * b , int brow , int bcol , int * c , int crow , int ccol ) ; 函数调用为： multimatrix ( *a , m, p , *b , p, n , *c , m, n ) multimatrix 函数体应该如何访问数组？ bool multimatrix ( const int a[m][p] , int arow , int acol , const int b[p][n] , int brow , int bcol , int c[m][n] , int crow , int ccol ) { if ( acol != brow ) return false ; //判断参数合法性 if ( crow != arow ) return false ; if ( ccol != bcol ) return false ; for ( int i = 0 ; i < crow ; i ++ ) //计算矩阵相乘 for ( int j = 0 ; j < ccol ; j ++ ) { for ( int n = 0 ; n < acol ; n ++ ) c [ i ] [ j ] += a [ i ] [ n ] * b [ n ] [ j ] ; } return true ;

4.5 动态存储 C++的动态存储分配机制可以根据需要 在程序运行时建立和撤销对象

4.5.1 new 和 delete 操作符 new 运算符动态分配堆内存 指针变量 = new 类型[表达式]； 作用：从堆分配一块“类型”大小的存储空间，返回首地址 其中：“常量”是初始化值，可缺省 创建数组对象时，不能为对象指定初始值 delete 运算符释放已分配的内存空间 使用形式： delete 指针变量 ； delete [] 指针变量 ； 其中：“指针变量”必须是一个 new 返回的指针

4.5.1 new 和 delete 操作符 int * p1 = new int ; char * p2 = new char ; double * p3 = new double ; int * p4 = new int [4] ; …… delete p1 ; delete p2 ; delete p3 ; delete [] p4 ;

4.5.1 new 和 delete 操作符 p1 int * p1 = new int ; char * p2 = new char ; double * p3 = new double ; int * p4 = new int [4] ; …… delete p1 ; delete p2 ; delete p3 ; delete [] p4 ;

4.5.1 new 和 delete 操作符 p1 int * p1 = new int ; char * p2 = new char ; double * p3 = new double ; int * p4 = new int [4] ; …… delete p1 ; delete p2 ; delete p3 ; delete [] p4 ; p2

4.5.1 new 和 delete 操作符 p1 int * p1 = new int ; char * p2 = new char ; double * p3 = new double ; int * p4 = new int [4] ; …… delete p1 ; delete p2 ; delete p3 ; delete [] p4 ; p2 p3

4.5.1 new 和 delete 操作符 p1 int * p1 = new int ; char * p2 = new char ; double * p3 = new double ; int * p4 = new int [4] ; …… delete p1 ; delete p2 ; delete p3 ; delete [] p4 ; p2 p3 p4

4.5.1 new 和 delete 操作符 p1 int * p1 = new int ; char * p2 = new char ; double * p3 = new double ; int * p4 = new int [4] ; …… delete p1 ; delete p2 ; delete p3 ; delete [] p4 ; p2 p3 p4

4.5.1 new 和 delete 操作符 p1 int * p1 = new int ; char * p2 = new char ; double * p3 = new double ; int * p4 = new int [4] ; …… delete p1 ; delete p2 ; delete p3 ; delete [] p4 ; p2 p3 p4

4.5.1 new 和 delete 操作符 p1 int * p1 = new int ; char * p2 = new char ; double * p3 = new double ; int * p4 = new int [4] ; …… delete p1 ; delete p2 ; delete p3 ; delete [] p4 ; p2 p3 p4

4.5.1 new 和 delete 操作符 p1 int * p1 = new int ; char * p2 = new char ; double * p3 = new double ; int * p4 = new int [4] ; …… delete p1 ; delete p2 ; delete p3 ; delete [] p4 ; p2 p3 p4

4.5.1 new 和 delete 操作符 p1 int * p1 = new int ; char * p2 = new char ; double * p3 = new double ; int * p4 = new int [4] ; …… delete p1 ; delete p2 ; delete p3 ; delete [] p4 ; p2 p3 p4

4.5.1 new 和 delete 操作符 p1 int * p1 = new int ; char * p2 = new char ; double * p3 = new double ; int * p4 = new int [4] ; …… delete p1 ; delete p2 ; delete p3 ; delete [] p4 ; p2 p3 p4

4.5.1 new 和 delete 操作符 p1 int * p1 = new int ; char * p2 = new char ; double * p3 = new double ; int * p4 = new int [4] ; …… delete p1 ; delete p2 ; delete p3 ; delete [] p4 ; p2 p3 p4

4.5.1 new 和 delete 操作符 p1 int * p1 = new int ; char * p2 = new char ; double * p3 = new double ; int * p4 = new int [4] ; …… delete p1 ; delete p2 ; delete p3 ; delete [] p4 ; p2 p3 p4

4.5.1 new 和 delete 操作符 p1 int * p1 = new int ; char * p2 = new char ; double * p3 = new double ; int * p4 = new int [4] ; …… delete p1 ; delete p2 ; delete p3 ; delete [] p4 ; p2 p3 p4

4.5.2 动态存储的应用 例4-16 用 new 算符建立简单对象 #include<iostream> 4.5.2 动态存储的应用 4.5.1 new 和 delete 操作符 例4-16 用 new 算符建立简单对象 #include<iostream> using namespace std ; int main() { int * p = NULL ; p = new int ( 89 ) ; //初始化存储区 if ( p == NULL ) { cout << "allocation faiure\n"; return 1; } cout << *p ; delete p ; }

4.5.2 动态存储的应用 例4-16 用 new 算符建立简单对象 #include<iostream> p 4.5.2 动态存储的应用 4.5.1 new 和 delete 操作符 例4-16 用 new 算符建立简单对象 #include<iostream> using namespace std ; int main() { int * p = NULL ; p = new int ( 89 ) ; //初始化存储区 if ( p == NULL ) { cout << "allocation faiure\n"; return 1; } cout << *p ; delete p ; } p

4.5.2 动态存储的应用 例4-16 用 new 算符建立简单对象 #include<iostream> p 4.5.2 动态存储的应用 4.5.1 new 和 delete 操作符 例4-16 用 new 算符建立简单对象 #include<iostream> using namespace std ; int main() { int * p = NULL ; p = new int ( 89 ) ; //初始化存储区 if ( p == NULL ) { cout << "allocation faiure\n"; return 1; } cout << *p ; delete p ; } p 89

4.5.2 动态存储的应用 例4-16 用 new 算符建立简单对象 #include<iostream> p 4.5.1 new 和 delete 操作符 4.5.2 动态存储的应用 例4-16 用 new 算符建立简单对象 #include<iostream> using namespace std ; int main() { int * p = NULL ; p = new int ( 89 ) ; //初始化存储区 if ( p == NULL ) { cout << "allocation faiure\n"; return 1; } cout << *p ; delete p ; } p 89

4.5.2 动态存储的应用 例4-16 用 new 算符建立简单对象 #include<iostream> p 4.5.2 动态存储的应用 4.5.1 new 和 delete 操作符 例4-16 用 new 算符建立简单对象 #include<iostream> using namespace std ; int main() { int * p = NULL ; p = new int ( 89 ) ; //初始化存储区 if ( p == NULL ) { cout << "allocation faiure\n"; return 1; } cout << *p ; delete p ; } p 89 对象无名 只能通过指针访问 89

4.5.2 动态存储的应用 例4-16 用 new 算符建立简单对象 #include<iostream> p 4.5.2 动态存储的应用 4.5.1 new 和 delete 操作符 例4-16 用 new 算符建立简单对象 #include<iostream> using namespace std ; int main() { int * p = NULL ; p = new int ( 89 ) ; //初始化存储区 if ( p == NULL ) { cout << "allocation faiure\n"; return 1; } cout << *p ; delete p ; } p 89 89

4.5.2 动态存储的应用 例4-16 用 new 算符建立简单对象 #include<iostream> p 4.5.2 动态存储的应用 4.5.1 new 和 delete 操作符 例4-16 用 new 算符建立简单对象 #include<iostream> using namespace std ; int main() { int * p = NULL ; p = new int ( 89 ) ; //初始化存储区 if ( p == NULL ) { cout << "allocation faiure\n"; return 1; } cout << *p ; delete p ; } p 89 89

4.5.2 动态存储的应用 例4-17-1 用 new 算符建立动态数组 #include<iostream> 4.5.2 动态存储的应用 4.5.1 new 和 delete 操作符 例4-17-1 用 new 算符建立动态数组 #include<iostream> using namespace std ; int main() { int * p = NULL , * t ; int i ; p = new int [10] ; if ( p == NULL ) { cout << "allocation faiure\n" ; return 1; } for ( i = 0 ; i < 10 ; i ++ ) p[i] = 100 + i ; cout << endl ; for ( t = p ; t < p+10 ; t ++ ) cout << *t << " " ; delete [] p ; }

4.5.2 动态存储的应用 i 例4-17-1 用 new 算符建立动态数组 p #include<iostream> 4.5.2 动态存储的应用 4.5.1 new 和 delete 操作符 p t i 例4-17-1 用 new 算符建立动态数组 #include<iostream> using namespace std ; int main() { int * p = NULL , * t ; int i ; p = new int [10] ; if ( p == NULL ) { cout << "allocation faiure\n" ; return 1; } for ( i = 0 ; i < 10 ; i ++ ) p[i] = 100 + i ; cout << endl ; for ( t = p ; t < p+10 ; t ++ ) cout << *t << " " ; delete [] p ; }

4.5.2 动态存储的应用 i 例4-17-1 用 new 算符建立动态数组 p #include<iostream> 4.5.2 动态存储的应用 4.5.1 new 和 delete 操作符 i 例4-17-1 用 new 算符建立动态数组 p #include<iostream> using namespace std ; int main() { int * p = NULL , * t ; int i ; p = new int [10] ; if ( p == NULL ) { cout << "allocation faiure\n" ; return 1; } for ( i = 0 ; i < 10 ; i ++ ) p[i] = 100 + i ; cout << endl ; for ( t = p ; t < p+10 ; t ++ ) cout << *t << " " ; delete [] p ; } t

4.5.2 动态存储的应用 i 例4-17-1 用 new 算符建立动态数组 p #include<iostream> 4.5.2 动态存储的应用 4.5.1 new 和 delete 操作符 i 例4-17-1 用 new 算符建立动态数组 p #include<iostream> using namespace std ; int main() { int * p = NULL , * t ; int i ; p = new int [10] ; if ( p == NULL ) { cout << "allocation faiure\n" ; return 1; } for ( i = 0 ; i < 10 ; i ++ ) p[i] = 100 + i ; cout << endl ; for ( t = p ; t < p+10 ; t ++ ) cout << *t << " " ; delete [] p ; } t

4.5.2 动态存储的应用 i 例4-17-1 用 new 算符建立动态数组 p #include<iostream> 4.5.2 动态存储的应用 4.5.1 new 和 delete 操作符 i 例4-17-1 用 new 算符建立动态数组 p #include<iostream> using namespace std ; int main() { int * p = NULL , * t ; int i ; p = new int [10] ; if ( p == NULL ) { cout << "allocation faiure\n" ; return 1; } for ( i = 0 ; i < 10 ; i ++ ) p[i] = 100 + i ; cout << endl ; for ( t = p ; t < p+10 ; t ++ ) cout << *t << " " ; delete [] p ; } 100 101 102 103 104 105 106 107 108 109 t

4.5.2 动态存储的应用 i 例4-17-1 用 new 算符建立动态数组 p #include<iostream> 4.5.2 动态存储的应用 4.5.1 new 和 delete 操作符 10 i 例4-17-1 用 new 算符建立动态数组 p #include<iostream> using namespace std ; int main() { int * p = NULL , * t ; int i ; p = new int [10] ; if ( p == NULL ) { cout << "allocation faiure\n" ; return 1; } for ( i = 0 ; i < 10 ; i ++ ) p[i] = 100 + i ; cout << endl ; for ( t = p ; t < p+10 ; t ++ ) cout << *t << " " ; delete [] p ; } 100 101 102 103 104 105 106 107 108 109 t |

4.5.2 动态存储的应用 i 例4-17-1 用 new 算符建立动态数组 p #include<iostream> 4.5.2 动态存储的应用 4.5.1 new 和 delete 操作符 10 i 例4-17-1 用 new 算符建立动态数组 p #include<iostream> using namespace std ; int main() { int * p = NULL , * t ; int i ; p = new int [10] ; if ( p == NULL ) { cout << "allocation faiure\n" ; return 1; } for ( i = 0 ; i < 10 ; i ++ ) p[i] = 100 + i ; cout << endl ; for ( t = p ; t < p+10 ; t ++ ) cout << *t << " " ; delete [] p ; } 100 101 102 103 104 105 106 107 108 109 t |

4.5.2 动态存储的应用 i 例4-17-1 用 new 算符建立动态数组 p #include<iostream> 4.5.2 动态存储的应用 4.5.1 new 和 delete 操作符 10 i 例4-17-1 用 new 算符建立动态数组 p #include<iostream> using namespace std ; int main() { int * p = NULL , * t ; int i ; p = new int [10] ; if ( p == NULL ) { cout << "allocation faiure\n" ; return 1; } for ( i = 0 ; i < 10 ; i ++ ) p[i] = 100 + i ; cout << endl ; for ( t = p ; t < p+10 ; t ++ ) cout << *t << " " ; delete [] p ; } 100 101 102 103 104 105 106 107 108 109 t |

4.5.2 动态存储的应用 i 例4-17-1 用 new 算符建立动态数组 p #include<iostream> 4.5.2 动态存储的应用 4.5.1 new 和 delete 操作符 10 i 例4-17-1 用 new 算符建立动态数组 p #include<iostream> using namespace std ; int main() { int * p = NULL , * t ; int i ; p = new int [10] ; if ( p == NULL ) { cout << "allocation faiure\n" ; return 1; } for ( i = 0 ; i < 10 ; i ++ ) p[i] = 100 + i ; cout << endl ; for ( t = p ; t < p+10 ; t ++ ) cout << *t << " " ; delete [] p ; } 100 101 102 103 104 105 106 107 108 109 t 100 |

4.5.2 动态存储的应用 i 例4-17-1 用 new 算符建立动态数组 p #include<iostream> 4.5.2 动态存储的应用 4.5.1 new 和 delete 操作符 10 i 例4-17-1 用 new 算符建立动态数组 p #include<iostream> using namespace std ; int main() { int * p = NULL , * t ; int i ; p = new int [10] ; if ( p == NULL ) { cout << "allocation faiure\n" ; return 1; } for ( i = 0 ; i < 10 ; i ++ ) p[i] = 100 + i ; cout << endl ; for ( t = p ; t < p+10 ; t ++ ) cout << *t << " " ; delete [] p ; } 100 101 102 103 104 105 106 107 108 109 t 100 |

4.5.2 动态存储的应用 i 例4-17-1 用 new 算符建立动态数组 p #include<iostream> 4.5.2 动态存储的应用 4.5.1 new 和 delete 操作符 10 i 例4-17-1 用 new 算符建立动态数组 p #include<iostream> using namespace std ; int main() { int * p = NULL , * t ; int i ; p = new int [10] ; if ( p == NULL ) { cout << "allocation faiure\n" ; return 1; } for ( i = 0 ; i < 10 ; i ++ ) p[i] = 100 + i ; cout << endl ; for ( t = p ; t < p+10 ; t ++ ) cout << *t << " " ; delete [] p ; } 100 101 102 103 104 105 106 107 108 109 t 100 |

4.5.2 动态存储的应用 i 例4-17-1 用 new 算符建立动态数组 p #include<iostream> 4.5.2 动态存储的应用 4.5.1 new 和 delete 操作符 10 i 例4-17-1 用 new 算符建立动态数组 p #include<iostream> using namespace std ; int main() { int * p = NULL , * t ; int i ; p = new int [10] ; if ( p == NULL ) { cout << "allocation faiure\n" ; return 1; } for ( i = 0 ; i < 10 ; i ++ ) p[i] = 100 + i ; cout << endl ; for ( t = p ; t < p+10 ; t ++ ) cout << *t << " " ; delete [] p ; } 100 101 102 103 104 105 106 107 108 109 t 100 101 |

4.5.2 动态存储的应用 i p 例4-17-1 用 new 算符建立动态数组 #include<iostream> 4.5.2 动态存储的应用 4.5.1 new 和 delete 操作符 10 i p 例4-17-1 用 new 算符建立动态数组 #include<iostream> using namespace std ; int main() { int * p = NULL , * t ; int i ; p = new int [10] ; if ( p == NULL ) { cout << "allocation faiure\n" ; return 1; } for ( i = 0 ; i < 10 ; i ++ ) p[i] = 100 + i ; cout << endl ; for ( t = p ; t < p+10 ; t ++ ) cout << *t << " " ; delete [] p ; } 100 101 102 103 104 105 106 107 108 109 t 100 101 |

4.5.2 动态存储的应用 i 例4-17-1 用 new 算符建立动态数组 p #include<iostream> 4.5.2 动态存储的应用 4.5.1 new 和 delete 操作符 10 i 例4-17-1 用 new 算符建立动态数组 p #include<iostream> using namespace std ; int main() { int * p = NULL , * t ; int i ; p = new int [10] ; if ( p == NULL ) { cout << "allocation faiure\n" ; return 1; } for ( i = 0 ; i < 10 ; i ++ ) p[i] = 100 + i ; cout << endl ; for ( t = p ; t < p+10 ; t ++ ) cout << *t << " " ; delete [] p ; } 100 101 102 103 104 105 106 107 108 109 t 100 101 |

4.5.2 动态存储的应用 i 例4-17-1 用 new 算符建立动态数组 p #include<iostream> 4.5.2 动态存储的应用 4.5.1 new 和 delete 操作符 10 i 例4-17-1 用 new 算符建立动态数组 p #include<iostream> using namespace std ; int main() { int * p = NULL , * t ; int i ; p = new int [10] ; if ( p == NULL ) { cout << "allocation faiure\n" ; return 1; } for ( i = 0 ; i < 10 ; i ++ ) p[i] = 100 + i ; cout << endl ; for ( t = p ; t < p+10 ; t ++ ) cout << *t << " " ; delete [] p ; } 100 101 102 103 104 105 106 107 108 109 t 100 101 |

4.5.2 动态存储的应用 i 例4-17-1 用 new 算符建立动态数组 p #include<iostream> 4.5.2 动态存储的应用 4.5.1 new 和 delete 操作符 10 i 例4-17-1 用 new 算符建立动态数组 p #include<iostream> using namespace std ; int main() { int * p = NULL , * t ; int i ; p = new int [10] ; if ( p == NULL ) { cout << "allocation faiure\n" ; return 1; } for ( i = 0 ; i < 10 ; i ++ ) p[i] = 100 + i ; cout << endl ; for ( t = p ; t < p+10 ; t ++ ) cout << *t << " " ; delete [] p ; } 100 101 102 103 104 105 106 107 108 109 t 100 101 102 |

4.5.2 动态存储的应用 i 例4-17-1 用 new 算符建立动态数组 p #include<iostream> 4.5.2 动态存储的应用 4.5.1 new 和 delete 操作符 10 i 例4-17-1 用 new 算符建立动态数组 p #include<iostream> using namespace std ; int main() { int * p = NULL , * t ; int i ; p = new int [10] ; if ( p == NULL ) { cout << "allocation faiure\n" ; return 1; } for ( i = 0 ; i < 10 ; i ++ ) p[i] = 100 + i ; cout << endl ; for ( t = p ; t < p+10 ; t ++ ) cout << *t << " " ; delete [] p ; } 100 101 102 103 104 105 106 107 108 109 t 100 101 102 |

4.5.2 动态存储的应用 i 例4-17-1 用 new 算符建立动态数组 p #include<iostream> 4.5.2 动态存储的应用 4.5.1 new 和 delete 操作符 10 i 例4-17-1 用 new 算符建立动态数组 p #include<iostream> using namespace std ; int main() { int * p = NULL , * t ; int i ; p = new int [10] ; if ( p == NULL ) { cout << "allocation faiure\n" ; return 1; } for ( i = 0 ; i < 10 ; i ++ ) p[i] = 100 + i ; cout << endl ; for ( t = p ; t < p+10 ; t ++ ) cout << *t << " " ; delete [] p ; } 100 101 102 103 104 105 106 107 108 109 t 100 101 102 |

4.5.2 动态存储的应用 i 例4-17-1 用 new 算符建立动态数组 p #include<iostream> 4.5.2 动态存储的应用 4.5.1 new 和 delete 操作符 10 i 例4-17-1 用 new 算符建立动态数组 p #include<iostream> using namespace std ; int main() { int * p = NULL , * t ; int i ; p = new int [10] ; if ( p == NULL ) { cout << "allocation faiure\n" ; return 1; } for ( i = 0 ; i < 10 ; i ++ ) p[i] = 100 + i ; cout << endl ; for ( t = p ; t < p+10 ; t ++ ) cout << *t << " " ; delete [] p ; } 100 101 102 103 104 105 106 107 108 109 t 100 101 102 |

4.5.2 动态存储的应用 i 例4-17-1 用 new 算符建立动态数组 p #include<iostream> 4.5.2 动态存储的应用 4.5.1 new 和 delete 操作符 10 i 例4-17-1 用 new 算符建立动态数组 p #include<iostream> using namespace std ; int main() { int * p = NULL , * t ; int i ; p = new int [10] ; if ( p == NULL ) { cout << "allocation faiure\n" ; return 1; } for ( i = 0 ; i < 10 ; i ++ ) p[i] = 100 + i ; cout << endl ; for ( t = p ; t < p+10 ; t ++ ) cout << *t << " " ; delete [] p ; } 100 101 102 103 104 105 106 107 108 109 t 100 101 102 103 |

4.5.2 动态存储的应用 i 例4-17-1 用 new 算符建立动态数组 p #include<iostream> 4.5.2 动态存储的应用 4.5.1 new 和 delete 操作符 10 i 例4-17-1 用 new 算符建立动态数组 p #include<iostream> using namespace std ; int main() { int * p = NULL , * t ; int i ; p = new int [10] ; if ( p == NULL ) { cout << "allocation faiure\n" ; return 1; } for ( i = 0 ; i < 10 ; i ++ ) p[i] = 100 + i ; cout << endl ; for ( t = p ; t < p+10 ; t ++ ) cout << *t << " " ; delete [] p ; } 100 101 102 103 104 105 106 107 108 109 t 100 101 102 103 104 105 106 107 108 109 |

4.5.2 动态存储的应用 i 例4-17-1 用 new 算符建立动态数组 p #include<iostream> 4.5.2 动态存储的应用 4.5.1 new 和 delete 操作符 10 i 例4-17-1 用 new 算符建立动态数组 p #include<iostream> using namespace std ; int main() { int * p = NULL , * t ; int i ; p = new int [10] ; if ( p == NULL ) { cout << "allocation faiure\n" ; return 1; } for ( i = 0 ; i < 10 ; i ++ ) p[i] = 100 + i ; cout << endl ; for ( t = p ; t < p+10 ; t ++ ) cout << *t << " " ; delete [] p ; } 100 101 102 103 104 105 106 107 108 109 t 100 101 102 103 104 105 106 107 108 109 |

4.5.2 动态存储的应用 i 例4-17-1 用 new 算符建立动态数组 p #include<iostream> 4.5.2 动态存储的应用 10 i 例4-17-1 用 new 算符建立动态数组 p #include<iostream> using namespace std ; int main() { int * p = NULL , * t ; int i ; p = new int [10] ; if ( p == NULL ) { cout << "allocation faiure\n" ; return 1; } for ( i = 0 ; i < 10 ; i ++ ) p[i] = 100 + i ; cout << endl ; for ( t = p ; t < p+10 ; t ++ ) cout << *t << " " ; delete [] p ; } 100 101 102 103 104 105 106 107 108 109 t 100 101 102 103 104 105 106 107 108 109 |

4.5.2 动态存储的应用 i 例4-17-1 用 new 算符建立动态数组 p #include<iostream> 4.5.2 动态存储的应用 4.5.1 new 和 delete 操作符 10 i 例4-17-1 用 new 算符建立动态数组 p #include<iostream> using namespace std ; int main() { int * p = NULL , * t ; int i ; p = new int [10] ; if ( p == NULL ) { cout << "allocation faiure\n" ; return 1; } for ( i = 0 ; i < 10 ; i ++ ) p[i] = 100 + i ; cout << endl ; for ( t = p ; t < p+10 ; t ++ ) cout << *t << " " ; delete [] p ; } 100 101 102 103 104 105 106 107 108 109 t 100 101 102 103 104 105 106 107 108 109 |

4.5.2 动态存储的应用 i 例4-17-1 用 new 算符建立动态数组 p #include<iostream> 4.5.2 动态存储的应用 4.5.1 new 和 delete 操作符 10 i 例4-17-1 用 new 算符建立动态数组 p #include<iostream> using namespace std ; int main() { int * p = NULL , * t ; int i ; p = new int [10] ; if ( p == NULL ) { cout << "allocation faiure\n" ; return 1; } for ( i = 0 ; i < 10 ; i ++ ) p[i] = 100 + i ; cout << endl ; for ( t = p ; t < p+10 ; t ++ ) cout << *t << " " ; delete [] p ; } 100 101 102 103 104 105 106 107 108 109 t 100 101 102 103 104 105 106 107 108 109 |

4.5.2 动态存储的应用 i 例4-17-1 用 new 算符建立动态数组 p #include<iostream> 4.5.2 动态存储的应用 4.5.1 new 和 delete 操作符 10 i 例4-17-1 用 new 算符建立动态数组 p #include<iostream> using namespace std ; int main() { int * p = NULL , * t ; int i ; p = new int [10] ; if ( p == NULL ) { cout << "allocation faiure\n" ; return 1; } for ( i = 0 ; i < 10 ; i ++ ) p[i] = 100 + i ; cout << endl ; for ( t = p ; t < p+10 ; t ++ ) cout << *t << " " ; delete [] p ; } 100 101 102 103 104 105 106 107 108 109 t

4.5.2 动态存储的应用 i 例4-17-1 用 new 算符建立动态数组 p #include<iostream> 4.5.2 动态存储的应用 4.5.1 new 和 delete 操作符 10 i 例4-17-1 用 new 算符建立动态数组 p #include<iostream> using namespace std ; int main() { int * p = NULL , * t ; int i ; p = new int [10] ; if ( p == NULL ) { cout << "allocation faiure\n" ; return 1; } for ( i = 0 ; i < 10 ; i ++ ) p[i] = 100 + i ; cout << endl ; for ( t = p ; t < p+10 ; t ++ ) cout << *t << " " ; delete [] p ; } 100 101 102 103 104 105 106 107 108 109 以下标方式 访问动态数组 t

4.5.2 动态存储的应用 i 例4-17-1 用 new 算符建立动态数组 p #include<iostream> 4.5.2 动态存储的应用 4.5.1 new 和 delete 操作符 10 i 例4-17-1 用 new 算符建立动态数组 p #include<iostream> using namespace std ; int main() { int * p = NULL , * t ; int i ; p = new int [10] ; if ( p == NULL ) { cout << "allocation faiure\n" ; return 1; } for ( i = 0 ; i < 10 ; i ++ ) p[i] = 100 + i ; cout << endl ; for ( t = p ; t < p+10 ; t ++ ) cout << *t << " " ; delete [] p ; } 100 101 102 103 104 105 106 107 108 109 i 是偏移量 p 指针本身值不变 t

4.5.2 动态存储的应用 i 例4-17-1 用 new 算符建立动态数组 p #include<iostream> 4.5.2 动态存储的应用 4.5.1 new 和 delete 操作符 10 i 例4-17-1 用 new 算符建立动态数组 p #include<iostream> using namespace std ; int main() { int * p = NULL , * t ; int i ; p = new int [10] ; if ( p == NULL ) { cout << "allocation faiure\n" ; return 1; } for ( i = 0 ; i < 10 ; i ++ ) p[i] = 100 + i ; cout << endl ; for ( t = p ; t < p+10 ; t ++ ) cout << *t << " " ; delete [] p ; } 100 101 102 103 104 105 106 107 108 109 跟踪指针赋初值 t

4.5.2 动态存储的应用 i 例4-17-1 用 new 算符建立动态数组 p #include<iostream> 4.5.2 动态存储的应用 4.5.1 new 和 delete 操作符 10 i 例4-17-1 用 new 算符建立动态数组 p #include<iostream> using namespace std ; int main() { int * p = NULL , * t ; int i ; p = new int [10] ; if ( p == NULL ) { cout << "allocation faiure\n" ; return 1; } for ( i = 0 ; i < 10 ; i ++ ) p[i] = 100 + i ; cout << endl ; for ( t = p ; t < p+10 ; t ++ ) cout << *t << " " ; delete [] p ; } 100 101 102 103 104 105 106 107 108 109 跟踪指针移动 t

4.5.2 动态存储的应用 i 例4-17-1 用 new 算符建立动态数组 p #include<iostream> 4.5.2 动态存储的应用 4.5.1 new 和 delete 操作符 10 i 例4-17-1 用 new 算符建立动态数组 p #include<iostream> using namespace std ; int main() { int * p = NULL , * t ; int i ; p = new int [10] ; if ( p == NULL ) { cout << "allocation faiure\n" ; return 1; } for ( i = 0 ; i < 10 ; i ++ ) p[i] = 100 + i ; cout << endl ; for ( t = p ; t < p+10 ; t ++ ) cout << *t << " " ; delete [] p ; } 100 101 102 103 104 105 106 107 108 109 间址访问元素 t

4.5.2 动态存储的应用 i 例4-17-1 用 new 算符建立动态数组 p #include<iostream> 4.5.2 动态存储的应用 4.5.1 new 和 delete 操作符 10 i 例4-17-1 用 new 算符建立动态数组 p #include<iostream> using namespace std ; int main() { int * p = NULL , * t ; int i ; p = new int [10] ; if ( p == NULL ) { cout << "allocation faiure\n" ; return 1; } for ( i = 0 ; i < 10 ; i ++ ) p[i] = 100 + i ; cout << endl ; for ( t = p ; t < p+10 ; t ++ ) cout << *t << " " ; delete [] p ; } 100 101 102 103 104 105 106 107 108 109 注意 结束循环后 for ( i = 0 ; i < 10 ; p ++, i++ ) cout << *p << " " ;

4.5.2 动态存储的应用 i 例4-17-1 用 new 算符建立动态数组 #include<iostream> 4.5.2 动态存储的应用 4.5.1 new 和 delete 操作符 10 i 例4-17-1 用 new 算符建立动态数组 #include<iostream> using namespace std ; int main() { int * p = NULL , * t ; int i ; p = new int [10] ; if ( p == NULL ) { cout << "allocation faiure\n" ; return 1; } for ( i = 0 ; i < 10 ; i ++ ) p[i] = 100 + i ; cout << endl ; for ( t = p ; t < p+10 ; t ++ ) cout << *t << " " ; delete [] p ; } 100 101 102 103 104 105 106 107 108 109 注意 结束循环后 for ( i = 0 ; i < 10 ; p ++, i++ ) cout << *p << " " ; p

4.5.2 动态存储的应用 i 例4-17-1 用 new 算符建立动态数组 #include<iostream> 4.5.2 动态存储的应用 4.5.1 new 和 delete 操作符 10 i 例4-17-1 用 new 算符建立动态数组 #include<iostream> using namespace std ; int main() { int * p = NULL , * t ; int i ; p = new int [10] ; if ( p == NULL ) { cout << "allocation faiure\n" ; return 1; } for ( i = 0 ; i < 10 ; i ++ ) p[i] = 100 + i ; cout << endl ; for ( t = p ; t < p+10 ; t ++ ) cout << *t << " " ; delete [] p ; } 100 101 102 103 104 105 106 107 108 109 注意 结束循环后 释放什么空间？ for ( i = 0 ; i < 10 ; p ++, i++ ) cout << *p << " " ; p

4.5.2 动态存储的应用 i 例4-17-1 用 new 算符建立动态数组 100 #include<iostream> 4.5.1 new 和 delete 操作符 4.5.2 动态存储的应用 10 i 例4-17-1 用 new 算符建立动态数组 #include<iostream> using namespace std ; int main() { int * p = NULL , * t ; int i ; p = new int [10] ; if ( p == NULL ) { cout << "allocation faiure\n" ; return 1; } for ( i = 0 ; i < 10 ; i ++ ) p[i] = 100 + i ; cout << endl ; for ( t = p ; t < p+10 ; t ++ ) cout << *t << " " ; delete [] p ; } 100 101 102 103 104 105 106 107 108 109 注意 结束循环后 内存泄漏 for ( i = 0 ; i < 10 ; p ++, i++ ) cout << *p << " " ; p

#include<iostream> using namespace std ; 4.5.1 new 和 delete 操作符 例4-17-2 调用函数建立动态数组 #include<iostream> using namespace std ; void App( int * & pa , int n ) ; int main() { int *ary = NULL, *t , i, n ; cout<<"n= "; cin>>n; App( ary, n ); for( i = 0; i<n; i++ ) {ary[i] = 10 + i ; cout<<ary[i]<<" "; } delete []ary; } void App( int * & pa , int len ) { pa = new int [len] ; if( pa == NULL ) { cout << "allocation faiure\n"; return ; } for( int i = 0; i<len; i++ ) pa[i] = 0 ;

App( ary, n ); 注意 int *&pa 例4-17-2 调用函数建立动态数组 #include<iostream> 4.5.1 new 和 delete 操作符 例4-17-2 调用函数建立动态数组 #include<iostream> using namespace std ; void App( int * & pa , int n ) ; int main() { int *ary = NULL, *t , i, n ; cout<<"n= "; cin>>n; App( ary, n ); for( i = 0; i<n; i++ ) {ary[i] = 10 + i ; cout<<ary[i]<<" "; } delete []ary; } void App( int * & pa , int len ) { pa = new int [len] ; if( pa == NULL ) { cout << "allocation faiure\n"; return ; } for( int i = 0; i<len; i++ ) pa[i] = 0 ; ary pa App( ary, n ); 指针引用参数 注意 int *&pa

int * pa App( ary, n ); 注意 int * pa 4.5.1 new 和 delete 操作符 例4-17-2 调用函数建立动态数组 #include<iostream> using namespace std ; void App( int * & pa , int n ) ; int main() { int *ary = NULL, *t , i, n ; cout<<"n= "; cin>>n; App( ary, n ); for( i = 0; i<n; i++ ) {ary[i] = 10 + i ; cout<<ary[i]<<" "; } delete []ary; } void App( int * & pa , int len ) { pa = new int [len] ; if( pa == NULL ) { cout << "allocation faiure\n"; return ; } for( int i = 0; i<len; i++ ) pa[i] = 0 ; ary pa int * pa App( ary, n ); 注意 int * pa

int * pa 讨论 App( ary, n ); int * pa 4.5.1 new 和 delete 操作符 例4-17-2 调用函数建立动态数组 #include<iostream> using namespace std ; void App( int * & pa , int n ) ; int main() { int *ary = NULL, *t , i, n ; cout<<"n= "; cin>>n; App( ary, n ); for( i = 0; i<n; i++ ) {ary[i] = 10 + i ; cout<<ary[i]<<" "; } delete []ary; } void App( int * & pa , int len ) { pa = new int [len] ; if( pa == NULL ) { cout << "allocation faiure\n"; return ; } for( int i = 0; i<len; i++ ) pa[i] = 0 ; ary pa int * pa 讨论 形参 int *pa是传地址值参数 调用函数时实参ary的值（NULL）赋给形参变量pa 函数App执行new操作把地址写入pa，与ary无关 函数返回后，ary不能获得动态数组的地址 App( ary, n ); int * pa { pa = new int [len] ;

注意 指针引用参数的作用 例4-17-2 调用函数建立动态数组 #include<iostream> 4.5.1 new 和 delete 操作符 例4-17-2 调用函数建立动态数组 #include<iostream> using namespace std ; void App( int * & pa , int n ) ; int main() { int *ary = NULL, *t , i, n ; cout<<"n= "; cin>>n; App( ary, n ); for( i = 0; i<n; i++ ) {ary[i] = 10 + i ; cout<<ary[i]<<" "; } delete []ary; } void App( int * & pa , int len ) { pa = new int [len] ; if( pa == NULL ) { cout << "allocation faiure\n"; return ; } for( int i = 0; i<len; i++ ) pa[i] = 0 ; ary pa 注意 指针引用参数的作用

例4-18 输出二项式系数表 ( a + b ) 0 = 1 ( a + b ) 1 = 1a + 1b 4.5.1 new 和 delete 操作符 例4-18 输出二项式系数表 ( a + b ) 0 = 1 ( a + b ) 1 = 1a + 1b ( a + b ) 2 = 1a2 + 2ab + 1b2 ( a + b ) 3 = 1a3 + 3a2b + 3ab2 + 1b3 ( a + b ) 4 = 1a4 + 4a3b + 6a2b2 + 4ab3 + 1b4 1 1 1 1 2 1 1 3 3 1 1 4 6 4 1 1 5 10 10 5 1 杨辉三角形

4.5.1 new 和 delete 操作符 例4-18 输出二项式系数表 1 1 1 1 2 1 1 3 3 1 1 4 6 4 1 1 5 10 10 5 1 杨辉三角形 算法分析 n 次系数表有 n +1 项 n 次系数表由 n -1 次系数表迭代生成： F0 = 1 Fn+1 = 1 Fi = Fi-1 + Fi

4.5.1 new 和 delete 操作符 例4-18 输出二项式系数表 1 1 1 1 2 1 1 3 3 1 1 4 6 4 1 1 5 10 10 5 1 杨辉三角形 算法分析 一维数组迭代生成 n 次系数表 n = 5 F0 F1 F2 F3 F4 F5

4.5.1 new 和 delete 操作符 例4-18 输出二项式系数表 1 1 1 1 2 1 1 3 3 1 1 4 6 4 1 1 5 10 10 5 1 杨辉三角形 算法分析 一维数组迭代生成 n 次系数表 n = 5 F0 F1 F2 F3 F4 F5 n = 0 1

4.5.1 new 和 delete 操作符 例4-18 输出二项式系数表 1 1 1 1 2 1 1 3 3 1 1 4 6 4 1 1 5 10 10 5 1 杨辉三角形 算法分析 一维数组迭代生成 n 次系数表 n = 5 F0 F1 F2 F3 F4 F5 n = 1 1 1

4.5.1 new 和 delete 操作符 例4-18 输出二项式系数表 1 1 1 1 2 1 1 3 3 1 1 4 6 4 1 1 5 10 10 5 1 杨辉三角形 算法分析 一维数组迭代生成 n 次系数表 n = 5 F0 F1 F2 F3 F4 F5 n = 2 1 1 1 +

4.5.1 new 和 delete 操作符 例4-18 输出二项式系数表 1 1 1 1 2 1 1 3 3 1 1 4 6 4 1 1 5 10 10 5 1 杨辉三角形 算法分析 一维数组迭代生成 n 次系数表 n = 5 F0 F1 F2 F3 F4 F5 n = 2 1 2 1 +

4.5.1 new 和 delete 操作符 例4-18 输出二项式系数表 1 1 1 1 2 1 1 3 3 1 1 4 6 4 1 1 5 10 10 5 1 杨辉三角形 算法分析 一维数组迭代生成 n 次系数表 n = 5 F0 F1 F2 F3 F4 F5 n = 3 1 2 1 1 +

4.5.1 new 和 delete 操作符 例4-18 输出二项式系数表 1 1 1 1 2 1 1 3 3 1 1 4 6 4 1 1 5 10 10 5 1 杨辉三角形 算法分析 一维数组迭代生成 n 次系数表 n = 5 F0 F1 F2 F3 F4 F5 n = 3 1 2 3 1 +

4.5.1 new 和 delete 操作符 例4-18 输出二项式系数表 1 1 1 1 2 1 1 3 3 1 1 4 6 4 1 1 5 10 10 5 1 杨辉三角形 算法分析 一维数组迭代生成 n 次系数表 n = 5 F0 F1 F2 F3 F4 F5 n = 3 1 2 3 1 +

4.5.1 new 和 delete 操作符 例4-18 输出二项式系数表 1 1 1 1 2 1 1 3 3 1 1 4 6 4 1 1 5 10 10 5 1 杨辉三角形 算法分析 一维数组迭代生成 n 次系数表 n = 5 F0 F1 F2 F3 F4 F5 n = 3 1 3 3 1 +

4.5.1 new 和 delete 操作符 例4-18 输出二项式系数表 1 1 1 1 2 1 1 3 3 1 1 4 6 4 1 1 5 10 10 5 1 杨辉三角形 算法分析 一维数组迭代生成 n 次系数表 n = 5 F0 F1 F2 F3 F4 F5 n = 4 1 3 3 1 1 +

4.5.1 new 和 delete 操作符 例4-18 输出二项式系数表 1 1 1 1 2 1 1 3 3 1 1 4 6 4 1 1 5 10 10 5 1 杨辉三角形 算法分析 一维数组迭代生成 n 次系数表 n = 5 F0 F1 F2 F3 F4 F5 n = 4 1 3 3 4 1 +

4.5.1 new 和 delete 操作符 例4-18 输出二项式系数表 1 1 1 1 2 1 1 3 3 1 1 4 6 4 1 1 5 10 10 5 1 杨辉三角形 算法分析 一维数组迭代生成 n 次系数表 n = 5 F0 F1 F2 F3 F4 F5 n = 4 1 3 3 4 1 +

4.5.1 new 和 delete 操作符 例4-18 输出二项式系数表 1 1 1 1 2 1 1 3 3 1 1 4 6 4 1 1 5 10 10 5 1 杨辉三角形 算法分析 一维数组迭代生成 n 次系数表 n = 5 F0 F1 F2 F3 F4 F5 n = 4 1 3 6 4 1 +

4.5.1 new 和 delete 操作符 例4-18 输出二项式系数表 1 1 1 1 2 1 1 3 3 1 1 4 6 4 1 1 5 10 10 5 1 杨辉三角形 算法分析 一维数组迭代生成 n 次系数表 n = 5 F0 F1 F2 F3 F4 F5 n = 4 1 3 6 4 1 +

4.5.1 new 和 delete 操作符 例4-18 输出二项式系数表 1 1 1 1 2 1 1 3 3 1 1 4 6 4 1 1 5 10 10 5 1 杨辉三角形 算法分析 一维数组迭代生成 n 次系数表 n = 5 F0 F1 F2 F3 F4 F5 n = 4 1 4 6 4 1 +

4.5.1 new 和 delete 操作符 例4-18 输出二项式系数表 1 1 1 1 2 1 1 3 3 1 1 4 6 4 1 1 5 10 10 5 1 杨辉三角形 算法分析 一维数组迭代生成 n 次系数表 n = 5 F0 F1 F2 F3 F4 F5 n = 5 1 4 6 4 1 1

4.5.1 new 和 delete 操作符 例4-18 输出二项式系数表 1 1 1 1 2 1 1 3 3 1 1 4 6 4 1 1 5 10 10 5 1 杨辉三角形 算法分析 一维数组迭代生成 n 次系数表 n = 5 F0 F1 F2 F3 F4 F5 n = 5 1 4 6 4 1 1 +

4.5.1 new 和 delete 操作符 例4-18 输出二项式系数表 1 1 1 1 2 1 1 3 3 1 1 4 6 4 1 1 5 10 10 5 1 杨辉三角形 算法分析 一维数组迭代生成 n 次系数表 n = 5 F0 F1 F2 F3 F4 F5 n = 5 1 4 6 4 5 1 +

4.5.1 new 和 delete 操作符 例4-18 输出二项式系数表 1 1 1 1 2 1 1 3 3 1 1 4 6 4 1 1 5 10 10 5 1 杨辉三角形 算法分析 一维数组迭代生成 n 次系数表 n = 5 F0 F1 F2 F3 F4 F5 n = 5 1 4 6 4 5 1 +

4.5.1 new 和 delete 操作符 例4-18 输出二项式系数表 1 1 1 1 2 1 1 3 3 1 1 4 6 4 1 1 5 10 10 5 1 杨辉三角形 算法分析 一维数组迭代生成 n 次系数表 n = 5 F0 F1 F2 F3 F4 F5 n = 5 1 4 6 10 5 1 +

4.5.1 new 和 delete 操作符 例4-18 输出二项式系数表 1 1 1 1 2 1 1 3 3 1 1 4 6 4 1 1 5 10 10 5 1 杨辉三角形 算法分析 一维数组迭代生成 n 次系数表 n = 5 F0 F1 F2 F3 F4 F5 n = 5 1 4 6 10 5 1 +

4.5.1 new 和 delete 操作符 例4-18 输出二项式系数表 1 1 1 1 2 1 1 3 3 1 1 4 6 4 1 1 5 10 10 5 1 杨辉三角形 算法分析 一维数组迭代生成 n 次系数表 n = 5 F0 F1 F2 F3 F4 F5 n = 5 1 4 10 10 5 1 +

4.5.1 new 和 delete 操作符 例4-18 输出二项式系数表 1 1 1 1 2 1 1 3 3 1 1 4 6 4 1 1 5 10 10 5 1 杨辉三角形 算法分析 一维数组迭代生成 n 次系数表 n = 5 F0 F1 F2 F3 F4 F5 n = 5 1 4 10 10 5 1 +

4.5.1 new 和 delete 操作符 例4-18 输出二项式系数表 1 1 1 1 2 1 1 3 3 1 1 4 6 4 1 1 5 10 10 5 1 杨辉三角形 算法分析 一维数组迭代生成 n 次系数表 n = 5 F0 F1 F2 F3 F4 F5 n = 5 1 5 10 10 5 1 +

4.5.1 new 和 delete 操作符 例4-18 输出二项式系数表 1 1 1 1 2 1 1 3 3 1 1 4 6 4 1 1 5 10 10 5 1 杨辉三角形 算法分析 一维数组迭代生成 n 次系数表 n = 5 F0 F1 F2 F3 F4 F5 n = 5 1 5 10 10 5 1

#include<iostream> using namespace std ; 4.5.1 new 和 delete 操作符 #include<iostream> using namespace std ; void yhtriangle( int * const, int ); int main() { int n , * yh ; do { cout << "Please input power:\n" ; cin >> n ; } while( n<0 || n>20 ) ; yh = new int [n+1] ; yhtriangle ( yh , n ) ; for ( int i = 0 ; i < n+1 ; i ++ ) cout << yh[i] << " " ; cout<<endl ; delete [] yh ; } void yhtriangle ( int * const py, int pn ) { int i , j ; py[0] = 1 ; for ( i = 1; i < pn+1; i ++ ) { py [i] = 1; for ( j = i-1 ; j > 0 ; j -- ) py[j] = py[j-1] + py[j] ; }

#include<iostream> using namespace std ; 4.5.1 new 和 delete 操作符 #include<iostream> using namespace std ; void yhtriangle( int * const, int ); int main() { int n , * yh ; do { cout << "Please input power:\n" ; cin >> n ; } while( n<0 || n>20 ) ; yh = new int [n+1] ; yhtriangle ( yh , n ) ; for ( int i = 0 ; i < n+1 ; i ++ ) cout << yh[i] << " " ; cout<<endl ; delete [] yh ; } 声明整型指针 void yhtriangle ( int * const py, int pn ) { int i , j ; py[0] = 1 ; for ( i = 1; i < pn+1; i ++ ) { py [i] = 1; for ( j = i-1 ; j > 0 ; j -- ) py[j] = py[j-1] + py[j] ; }

#include<iostream> using namespace std ; 4.5.1 new 和 delete 操作符 #include<iostream> using namespace std ; void yhtriangle( int * const, int ); int main() { int n , * yh ; do { cout << "Please input power:\n" ; cin >> n ; } while( n<0 || n>20 ) ; yh = new int [n+1] ; yhtriangle ( yh , n ) ; for ( int i = 0 ; i < n+1 ; i ++ ) cout << yh[i] << " " ; cout<<endl ; delete [] yh ; } 限制输出幂次 void yhtriangle ( int * const py, int pn ) { int i , j ; py[0] = 1 ; for ( i = 1; i < pn+1; i ++ ) { py [i] = 1; for ( j = i-1 ; j > 0 ; j -- ) py[j] = py[j-1] + py[j] ; }

#include<iostream> using namespace std ; 4.5.1 new 和 delete 操作符 #include<iostream> using namespace std ; void yhtriangle( int * const, int ); int main() { int n , * yh ; do { cout << "Please input power:\n" ; cin >> n ; } while( n<0 || n>20 ) ; yh = new int [n+1] ; yhtriangle ( yh , n ) ; for ( int i = 0 ; i < n+1 ; i ++ ) cout << yh[i] << " " ; cout<<endl ; delete [] yh ; } 创建动态数组 void yhtriangle ( int * const py, int pn ) { int i , j ; py[0] = 1 ; for ( i = 1; i < pn+1; i ++ ) { py [i] = 1; for ( j = i-1 ; j > 0 ; j -- ) py[j] = py[j-1] + py[j] ; }

#include<iostream> using namespace std ; 4.5.1 new 和 delete 操作符 #include<iostream> using namespace std ; void yhtriangle( int * const, int ); int main() { int n , * yh ; do { cout << "Please input power:\n" ; cin >> n ; } while( n<0 || n>20 ) ; yh = new int [n+1] ; yhtriangle ( yh , n ) ; for ( int i = 0 ; i < n+1 ; i ++ ) cout << yh[i] << " " ; cout<<endl ; delete [] yh ; } 调用函数 求系数表 void yhtriangle ( int * const py, int pn ) { int i , j ; py[0] = 1 ; for ( i = 1; i < pn+1; i ++ ) { py [i] = 1; for ( j = i-1 ; j > 0 ; j -- ) py[j] = py[j-1] + py[j] ; }

#include<iostream> using namespace std ; 4.5.1 new 和 delete 操作符 #include<iostream> using namespace std ; void yhtriangle( int * const, int ); int main() { int n , * yh ; do { cout << "Please input power:\n" ; cin >> n ; } while( n<0 || n>20 ) ; yh = new int [n+1] ; yhtriangle ( yh , n ) ; for ( int i = 0 ; i < n+1 ; i ++ ) cout << yh[i] << " " ; cout<<endl ; delete [] yh ; } 输出系数表 void yhtriangle ( int * const py, int pn ) { int i , j ; py[0] = 1 ; for ( i = 1; i < pn+1; i ++ ) { py [i] = 1; for ( j = i-1 ; j > 0 ; j -- ) py[j] = py[j-1] + py[j] ; }

#include<iostream> using namespace std ; 4.5.1 new 和 delete 操作符 #include<iostream> using namespace std ; void yhtriangle( int * const, int ); int main() { int n , * yh ; do { cout << "Please input power:\n" ; cin >> n ; } while( n<0 || n>20 ) ; yh = new int [n+1] ; yhtriangle ( yh , n ) ; for ( int i = 0 ; i < n+1 ; i ++ ) cout << yh[i] << " " ; cout<<endl ; delete [] yh ; } 释放动态数组 void yhtriangle ( int * const py, int pn ) { int i , j ; py[0] = 1 ; for ( i = 1; i < pn+1; i ++ ) { py [i] = 1; for ( j = i-1 ; j > 0 ; j -- ) py[j] = py[j-1] + py[j] ; }

#include<iostream> using namespace std ; 4.5.1 new 和 delete 操作符 #include<iostream> using namespace std ; void yhtriangle( int * const, int ); int main() { int n , * yh ; do { cout << "Please input power:\n" ; cin >> n ; } while( n<0 || n>20 ) ; yh = new int [n+1] ; yhtriangle ( yh , n ) ; for ( int i = 0 ; i < n+1 ; i ++ ) cout << yh[i] << " " ; cout<<endl ; delete [] yh ; } 约束形参指针只读 void yhtriangle ( int * const py, int pn ) { int i , j ; py[0] = 1 ; for ( i = 1; i < pn+1; i ++ ) { py [i] = 1; for ( j = i-1 ; j > 0 ; j -- ) py[j] = py[j-1] + py[j] ; }

#include<iostream> using namespace std ; 4.5.1 new 和 delete 操作符 #include<iostream> using namespace std ; void yhtriangle( int * const, int ); int main() { int n , * yh ; do { cout << "Please input power:\n" ; cin >> n ; } while( n<0 || n>20 ) ; yh = new int [n+1] ; yhtriangle ( yh , n ) ; for ( int i = 0 ; i < n+1 ; i ++ ) cout << yh[i] << " " ; cout<<endl ; delete [] yh ; } 对第 1 项赋值 并保持不变 void yhtriangle ( int * const py, int pn ) { int i , j ; py[0] = 1 ; for ( i = 1; i < pn+1; i ++ ) { py [i] = 1; for ( j = i-1 ; j > 0 ; j -- ) py[j] = py[j-1] + py[j] ; }

#include<iostream> using namespace std ; 4.5.1 new 和 delete 操作符 #include<iostream> using namespace std ; void yhtriangle( int * const, int ); int main() { int n , * yh ; do { cout << "Please input power:\n" ; cin >> n ; } while( n<0 || n>20 ) ; yh = new int [n+1] ; yhtriangle ( yh , n ) ; for ( int i = 0 ; i < n+1 ; i ++ ) cout << yh[i] << " " ; cout<<endl ; delete [] yh ; } 迭代各次系数表 void yhtriangle ( int * const py, int pn ) { int i , j ; py[0] = 1 ; for ( i = 1; i < pn+1; i ++ ) { py [i] = 1; for ( j = i-1 ; j > 0 ; j -- ) py[j] = py[j-1] + py[j] ; }

#include<iostream> using namespace std ; 4.5.1 new 和 delete 操作符 #include<iostream> using namespace std ; void yhtriangle( int * const, int ); int main() { int n , * yh ; do { cout << "Please input power:\n" ; cin >> n ; } while( n<0 || n>20 ) ; yh = new int [n+1] ; yhtriangle ( yh , n ) ; for ( int i = 0 ; i < n+1 ; i ++ ) cout << yh[i] << " " ; cout<<endl ; delete [] yh ; } 添加最后 1 项 void yhtriangle ( int * const py, int pn ) { int i , j ; py[0] = 1 ; for ( i = 1; i < pn+1; i ++ ) { py [i] = 1; for ( j = i-1 ; j > 0 ; j -- ) py[j] = py[j-1] + py[j] ; }

#include<iostream> using namespace std ; 4.5.1 new 和 delete 操作符 #include<iostream> using namespace std ; void yhtriangle( int * const, int ); int main() { int n , * yh ; do { cout << "Please input power:\n" ; cin >> n ; } while( n<0 || n>20 ) ; yh = new int [n+1] ; yhtriangle ( yh , n ) ; for ( int i = 0 ; i < n+1 ; i ++ ) cout << yh[i] << " " ; cout<<endl ; delete [] yh ; } 计算其余各项 void yhtriangle ( int * const py, int pn ) { int i , j ; py[0] = 1 ; for ( i = 1; i < pn+1; i ++ ) { py [i] = 1; for ( j = i-1 ; j > 0 ; j -- ) py[j] = py[j-1] + py[j] ; }

#include<iostream> using namespace std ; 4.5.1 new 和 delete 操作符 #include<iostream> using namespace std ; void yhtriangle( int * const, int ); int main() { int n , * yh ; do { cout << "Please input power:\n" ; cin >> n ; } while( n<0 || n>20 ) ; yh = new int [n+1] ; yhtriangle ( yh , n ) ; for ( int i = 0 ; i < n+1 ; i ++ ) cout << yh[i] << " " ; cout<<endl ; delete [] yh ; } void yhtriangle ( int * const py, int pn ) { int i , j ; py[0] = 1 ; for ( i = 1; i < pn+1; i ++ ) { py [i] = 1; for ( j = i-1 ; j > 0 ; j -- ) py[j] = py[j-1] + py[j] ; }

#include<iostream> using namespace std ; 4.5.1 new 和 delete 操作符 #include<iostream> using namespace std ; void yhtriangle( int * const, int ); int main() { int n , * yh ; do { cout << "Please input power:\n" ; cin >> n ; } while( n<0 || n>20 ) ; yh = new int [n+1] ; yhtriangle ( yh , n ) ; for ( int i = 0 ; i < n+1 ; i ++ ) cout << yh[i] << " " ; cout<<endl ; delete [] yh ; } 可以吗？ 为什么？ void yhtriangle ( int * const py, int pn ) { int i , j ; py[0] = 1 ; for ( i = 1; i < pn+1; i ++ ) { py [i] = 1; for ( j = i-1 ; j > 0 ; j -- ) py[j] = py[j-1] + py[j] ; } for ( j = 1 ；j < i ; j ++ )

4.6 字符数组与字符串 4.6.1 字符串存储 C++没有字符串类型，以字符数组作字符串： '\0' 为字符串结束标志 4.6 字符数组与字符串 4.6.1 字符串存储 C++没有字符串类型，以字符数组作字符串： '\0' 为字符串结束标志 '\0' 是ASCII码为0的不可显示字符，即“空操作符” 对字符数组以字符串常量进行初始化时，自动添加 '\0'

4.6.1 字符串存储 1．用字符数组存放字符串 字符数组不同的初始化方式： 逐个字符对数组元素赋初始值： 4.6.1 字符串存储 1．用字符数组存放字符串 字符数组不同的初始化方式： 逐个字符对数组元素赋初始值： char str1[10] = { 'S', 't', 'u', 'd', 'e', 'n', 't' } ;

4.6.1 字符串存储 1．用字符数组存放字符串 字符数组不同的初始化方式： 逐个字符对数组元素赋初始值： 4.6.1 字符串存储 普通数组 不添加 '\0' 1．用字符数组存放字符串 字符数组不同的初始化方式： 逐个字符对数组元素赋初始值： char str1[10] = { 'S', 't', 'u', 'd', 'e', 'n', 't' } ; S t u d e n

4.6.1 字符串存储 1．用字符数组存放字符串 字符数组不同的初始化方式： 逐个字符对数组元素赋初始值： 用串常量初始化 4.6.1 字符串存储 1．用字符数组存放字符串 字符串 添加 '\0' 字符数组不同的初始化方式： 逐个字符对数组元素赋初始值： 用串常量初始化 char str2[10] = { "Student" } ; char str3[] = { "Student" } ; char str4[] = "Student" ; S t u d e n \0

4.6.1 字符串存储 2．用字符指针管理串 char *string = "Student" ; 操作： 建立匿名空间 ; 4.6.1 字符串存储 2．用字符指针管理串 string S t u d e n \0 char *string = "Student" ; 操作： 建立匿名空间 ; strcpy ( string , "Student" ) ;

4.6.1 字符串存储 2．用字符指针管理串 char * name [ 5 ] 4.6.1 字符串存储 2．用字符指针管理串 char * name [ 5 ] = { "Li Hua" , "He Xiao Ming" , "Zhang Li" , "Sun Fei" , "Chen Biao" } name [0] name [1] name [2] name [3] name [4] L i H u a \0 H e X i a o M i n g \0 Z h a n g L i \0 S u n F e i \0 C h e n B i a o \0

4.6.2 字符串的访问 iostream 对字符串的扩充功能： 字符串常量、字符数组名、字符指针都表示字符串 4.6.2 字符串访问 4.6.2 字符串的访问 iostream 对字符串的扩充功能： 字符串常量、字符数组名、字符指针都表示字符串 输出字符指针就是输出整个字符串（全部字符） 输出字符指针的间接引用是输出单个字符 基本操作中，串名是地址： 字符串名的直接比较是地址比较 字符串名赋值是赋地址值

4.6.2 字符串的访问 //例4-19 字符数组的访问 #include<iostream> 4.6.2 字符串访问 4.6.2 字符串的访问 //例4-19 字符数组的访问 #include<iostream> using namespace std ; int main() { char ca [5] = { 'a' , 'b' , 'c' , 'd' , 'e' } ; for ( int i = 0 ; i < 5 ; i ++ ) cout << ca [i] ; //逐个数组元素输出 cout << endl ; cout << ca << endl ; //整体输出字符数组 }

4.6.2 字符串的访问 //例4-19 字符数组的访问 #include<iostream> 4.6.2 字符串访问 4.6.2 字符串的访问 数组初始化 没有结束符 //例4-19 字符数组的访问 #include<iostream> using namespace std ; int main() { char ca [5] = { 'a' , 'b' , 'c' , 'd' , 'e' } ; for ( int i = 0 ; i < 5 ; i ++ ) cout << ca [i] ; //逐个数组元素输出 cout << endl ; cout << ca << endl ; //整体输出字符数组 }

4.6.2 字符串的访问 //例4-19 字符数组的访问 #include<iostream> 4.6.2 字符串访问 4.6.2 字符串的访问 //例4-19 字符数组的访问 #include<iostream> using namespace std ; int main() { char ca [5] = { 'a' , 'b' , 'c' , 'd' , 'e' } ; for ( int i = 0 ; i < 5 ; i ++ ) cout << ca [i] ; //逐个数组元素输出 cout << endl ; cout << ca << endl ; //整体输出字符数组 } 可以正确显示字符串

4.6.2 字符串的访问 //例4-19 字符数组的访问 #include<iostream> 4.6.2 字符串访问 4.6.2 字符串的访问 //例4-19 字符数组的访问 #include<iostream> using namespace std ; int main() { char ca [5] = { 'a' , 'b' , 'c' , 'd' , 'e' } ; for ( int i = 0 ; i < 5 ; i ++ ) cout << ca [i] ; //逐个数组元素输出 cout << endl ; cout << ca << endl ; //整体输出字符数组 } 找不到结束符 字符串后显示无意义符号

4.6.2 字符串的访问 //例4-19 字符数组的访问 #include<iostream> 4.6.2 字符串访问 4.6.2 字符串的访问 //例4-19 字符数组的访问 #include<iostream> using namespace std ; int main() { char ca [5] = { 'a' , 'b' , 'c' , 'd' , 'e' } ; for ( int i = 0 ; i < 5 ; i ++ ) cout << ca [i] ; //逐个数组元素输出 cout << endl ; cout << ca << endl ; //整体输出字符数组 } static char cb [10] = { 'a' , 'b' , 'c' , 'd' , 'e' } ; for ( int i = 0 ; i < 5 ; i ++ ) cout << cb [i] ; cout << endl ; cout << cb << endl ;

4.6.2 字符串的访问 //例4-19 字符数组的访问 #include<iostream> 4.6.2 字符串访问 4.6.2 字符串的访问 静态数组 自动对其余元素初始化为'\0' //例4-19 字符数组的访问 #include<iostream> using namespace std ; int main() { char ca [5] = { 'a' , 'b' , 'c' , 'd' , 'e' } ; for ( int i = 0 ; i < 5 ; i ++ ) cout << ca [i] ; //逐个数组元素输出 cout << endl ; cout << ca << endl ; //整体输出字符数组 } static char cb [10] = { 'a' , 'b' , 'c' , 'd' , 'e' } ; for ( int i = 0 ; i < 5 ; i ++ ) cout << cb [i] ; cout << endl ; cout << cb << endl ;

4.6.2 字符串的访问 //例4-19 字符数组的访问 #include<iostream> 4.6.2 字符串访问 4.6.2 字符串的访问 //例4-19 字符数组的访问 #include<iostream> using namespace std ; int main() { char ca [5] = { 'a' , 'b' , 'c' , 'd' , 'e' } ; for ( int i = 0 ; i < 5 ; i ++ ) cout << ca [i] ; //逐个数组元素输出 cout << endl ; cout << ca << endl ; //整体输出字符数组 } 都能够 正确输出字符串 static char cb [10] = { 'a' , 'b' , 'c', 'd' , 'e' } ; for ( int i = 0 ; i < 5 ; i ++ ) cout << cb [i] ; cout << endl ; cout << cb << endl ;

4.6.2 字符串的访问 //例4-19 字符数组的访问 #include<iostream> 4.6.2 字符串访问 4.6.2 字符串的访问 //例4-19 字符数组的访问 #include<iostream> using namespace std ; int main() { char ca [5] = { 'a' , 'b' , 'c' , 'd' , 'e' } ; for ( int i = 0 ; i < 5 ; i ++ ) cout << ca [i] ; //逐个数组元素输出 cout << endl ; cout << ca << endl ; //整体输出字符数组 } char cc[ ] = { 'i' , 'j' , 'k' , 'l' , 'm' , '\0' }; for ( int i = 0 ; i < sizeof( cc ) / sizeof( char )-1 ; i ++ ) cout << cc[i] ; cout << endl ; cout << cc << endl ;

4.6.2 字符串的访问 //例4-19 字符数组的访问 #include<iostream> 4.6.2 字符串访问 4.6.2 字符串的访问 添加结束符 //例4-19 字符数组的访问 #include<iostream> using namespace std ; int main() { char ca [5] = { 'a' , 'b' , 'c' , 'd' , 'e' } ; for ( int i = 0 ; i < 5 ; i ++ ) cout << ca [i] ; //逐个数组元素输出 cout << endl ; cout << ca << endl ; //整体输出字符数组 } char cc[ ] = { 'i' , 'j' , 'k' , 'l' , 'm' , '\0' }; for ( int i = 0 ; i < sizeof( cc ) / sizeof( char )-1 ; i ++ ) cout << cc[i] ; cout << endl ; cout << cc << endl ;

4.6.2 字符串的访问 //例4-19 字符数组的访问 #include<iostream> 4.6.2 字符串访问 4.6.2 字符串的访问 //例4-19 字符数组的访问 #include<iostream> using namespace std ; int main() { char ca [5] = { 'a' , 'b' , 'c' , 'd' , 'e' } ; for ( int i = 0 ; i < 5 ; i ++ ) cout << ca [i] ; //逐个数组元素输出 cout << endl ; cout << ca << endl ; //整体输出字符数组 } 计算字节数 char cc[ ] = { 'i' , 'j' , 'k' , 'l' , 'm' , '\0' }; for ( int i = 0 ; i < sizeof( cc ) / sizeof( char )-1 ; i ++ ) cout << cc[i] ; cout << endl ; cout << cc << endl ;

4.6.2 字符串的访问 //例4-19 字符数组的访问 #include<iostream> 4.6.2 字符串访问 4.6.2 字符串的访问 //例4-19 字符数组的访问 #include<iostream> using namespace std ; int main() { char ca [5] = { 'a' , 'b' , 'c' , 'd' , 'e' } ; for ( int i = 0 ; i < 5 ; i ++ ) cout << ca [i] ; //逐个数组元素输出 cout << endl ; cout << ca << endl ; //整体输出字符数组 } char cd[ ] = "I am a student." ; for ( int i = 0 ; cd[i] != '\0' ; i ++ ) cout << cd[i] ; cout << endl ; cout << cd << endl ;

4.6.2 字符串的访问 //例4-19 字符数组的访问 #include<iostream> 4.6.2 字符串访问 4.6.2 字符串的访问 自动添加结束符 //例4-19 字符数组的访问 #include<iostream> using namespace std ; int main() { char ca [5] = { 'a' , 'b' , 'c' , 'd' , 'e' } ; for ( int i = 0 ; i < 5 ; i ++ ) cout << ca [i] ; //逐个数组元素输出 cout << endl ; cout << ca << endl ; //整体输出字符数组 } char cd[ ] = "I am a student." ; for ( int i = 0 ; cd[i] != '\0' ; i ++ ) cout << cd[i] ; cout << endl ; cout << cd << endl ;

4.6.2 字符串的访问 //例4-19 字符数组的访问 #include<iostream> 4.6.2 字符串访问 4.6.2 字符串的访问 //例4-19 字符数组的访问 #include<iostream> using namespace std ; int main() { char ca [5] = { 'a' , 'b' , 'c' , 'd' , 'e' } ; for ( int i = 0 ; i < 5 ; i ++ ) cout << ca [i] ; //逐个数组元素输出 cout << endl ; cout << ca << endl ; //整体输出字符数组 } 检查串结束符 char cd[ ] = "I am a student." ; for ( int i = 0 ; cd[i] != '\0' ; i ++ ) cout << cd[i] ; cout << endl ; cout << cd << endl ;

4.6.2 字符串的访问 //例4-19 字符数组的访问 #include<iostream> 4.6.2 字符串访问 4.6.2 字符串的访问 //例4-19 字符数组的访问 #include<iostream> using namespace std ; int main() { char ca [5] = { 'a' , 'b' , 'c' , 'd' , 'e' } ; for ( int i = 0 ; i < 5 ; i ++ ) cout << ca [i] ; //逐个数组元素输出 cout << endl ; cout << ca << endl ; //整体输出字符数组 } char ce[10] ; cin >> ce ; cout << ce << endl ;

4.6.2 字符串的访问 //例4-19 字符数组的访问 #include<iostream> 4.6.2 字符串访问 4.6.2 字符串的访问 //例4-19 字符数组的访问 #include<iostream> using namespace std ; int main() { char ca [5] = { 'a' , 'b' , 'c' , 'd' , 'e' } ; for ( int i = 0 ; i < 5 ; i ++ ) cout << ca [i] ; //逐个数组元素输出 cout << endl ; cout << ca << endl ; //整体输出字符数组 } 接受输入 空格或换行结束 char ce[10] ; cin >> ce ; cout << ce << endl ;

4.6.2 字符串的访问 //例4-19 字符数组的访问 #include<iostream> 4.6.2 字符串访问 4.6.2 字符串的访问 //例4-19 字符数组的访问 #include<iostream> using namespace std ; int main() { char ca [5] = { 'a' , 'b' , 'c' , 'd' , 'e' } ; for ( int i = 0 ; i < 5 ; i ++ ) cout << ca [i] ; //逐个数组元素输出 cout << endl ; cout << ca << endl ; //整体输出字符数组 } 键盘输入 char ce[10] ; cin >> ce ; cout << ce << endl ;

4.6.2 字符串的访问 //例4-19 字符数组的访问 #include<iostream> 4.6.2 字符串访问 4.6.2 字符串的访问 //例4-19 字符数组的访问 #include<iostream> using namespace std ; int main() { char ca [5] = { 'a' , 'b' , 'c' , 'd' , 'e' } ; for ( int i = 0 ; i < 5 ; i ++ ) cout << ca [i] ; //逐个数组元素输出 cout << endl ; cout << ca << endl ; //整体输出字符数组 } 输出显示 char ce[10] ; cin >> ce ; cout << ce << endl ;

4.6.2 字符串的访问 // 例4-20 字符指针表示串 #include<iostream> 4.6.2 字符串访问 4.6.2 字符串的访问 // 例4-20 字符指针表示串 #include<iostream> using namespace std ; int main() { char *s = "program" ; for ( int i = 0 ; i < 7 ; i ++ ) cout << * ( s + i ) ; cout << endl ; }

4.6.2 字符串的访问 // 例4-20 字符指针表示串 #include<iostream> 4.6.2 字符串访问 4.6.2 字符串的访问 // 例4-20 字符指针表示串 #include<iostream> using namespace std ; int main() { char *s = "program" ; for ( int i = 0 ; i < 7 ; i ++ ) cout << * ( s + i ) ; cout << endl ; } 建立匿名对象 s p r o g a m \0

4.6.2 字符串的访问 // 例4-20 字符指针表示串 #include<iostream> 4.6.2 字符串访问 4.6.2 字符串的访问 // 例4-20 字符指针表示串 #include<iostream> using namespace std ; int main() { char *s = "program" ; for ( int i = 0 ; i < 7 ; i ++ ) cout << * ( s + i ) ; cout << endl ; } s p r o g a m \0

4.6.2 字符串的访问 注意修改后的输出 // 例4-20 字符指针表示串 为什么？ #include<iostream> 4.6.2 字符串访问 4.6.2 字符串的访问 注意修改后的输出 为什么？ // 例4-20 字符指针表示串 #include<iostream> using namespace std ; int main() { char *s = "program" ; for ( int i = 0 ; i < 7 ; i ++ ) cout << * ( s + i ) ; } s p r o g a m \0 cout << ( s + i ) << endl ;

#include<iostream> using namespace std ; int main() 4.6.2 字符串访问 // 例4-21 指针数组表示的字符串 #include<iostream> using namespace std ; int main() { char *name[5] = { "Li Hua", "He Xiao Ming", "Zhang Li", "Sun Fei", "Chen Bao" }; for ( int i = 0 ; i < 5 ; i ++ ) cout << name[i] << endl ; } L i H u a \0 H e X i a o M i n g \0 Z h a n g L i \0 S u n F e i \0 C h e n B i a o \0 name [0] name [1] name [2] name [3] name [4]

#include<iostream> using namespace std ; int main() 4.6.2 字符串访问 // 例4-21 指针数组表示的字符串 #include<iostream> using namespace std ; int main() { char *name[5] = { "Li Hua", "He Xiao Ming", "Zhang Li", "Sun Fei", "Chen Bao" }; for ( int i = 0 ; i < 5 ; i ++ ) cout << name[i] << endl ; } 字符指针 输出串值 L i H u a \0 H e X i a o M i n g \0 Z h a n g L i \0 S u n F e i \0 C h e n B i a o \0 name [0] name [1] name [2] name [3] name [4]

#include<iostream> using namespace std ; int main() 4.6.2 字符串访问 // 例4-22 串的赋值 #include<iostream> using namespace std ; int main() { char str1[10] = "computer" , str2[10] , *sp ; int i = 0 ; while( str1[i] ) { str2[i] = str1[i++]; } str2[i] = '\0' ; sp = str1 ; cout << str1 << endl << str2 << endl << sp << endl; sp = "new string" ; cout << sp << endl ; }

#include<iostream> using namespace std ; int main() 4.6.2 字符串访问 // 例4-22 串的赋值 #include<iostream> using namespace std ; int main() { char str1[10] = "computer" , str2[10] , *sp ; int i = 0 ; while( str1[i] ) { str2[i] = str1[i++]; } str2[i] = '\0' ; sp = str1 ; cout << str1 << endl << str2 << endl << sp << endl; sp = "new string" ; cout << sp << endl ; } c o m p u t e r \0 str1 sp str2

#include<iostream> using namespace std ; int main() 4.6.2 字符串访问 // 例4-22 串的赋值 #include<iostream> using namespace std ; int main() { char str1[10] = "computer" , str2[10] , *sp ; int i = 0 ; while( str1[i] ) { str2[i] = str1[i++]; } str2[i] = '\0' ; sp = str1 ; cout << str1 << endl << str2 << endl << sp << endl; sp = "new string" ; cout << sp << endl ; } sp c o m p u t e r \0 str1 str2 c o m p u t e r

#include<iostream> using namespace std ; int main() 4.6.2 字符串访问 // 例4-22 串的赋值 #include<iostream> using namespace std ; int main() { char str1[10] = "computer" , str2[10] , *sp ; int i = 0 ; while( str1[i] ) { str2[i] = str1[i++]; } str2[i] = '\0' ; sp = str1 ; cout << str1 << endl << str2 << endl << sp << endl; sp = "new string" ; cout << sp << endl ; } sp c o m p u t e r \0 str1 str2 c o m p u t e r \0

#include<iostream> using namespace std ; int main() 4.6.2 字符串访问 // 例4-22 串的赋值 #include<iostream> using namespace std ; int main() { char str1[10] = "computer" , str2[10] , *sp ; int i = 0 ; while( str1[i] ) { str2[i] = str1[i++]; } str2[i] = '\0' ; sp = str1 ; cout << str1 << endl << str2 << endl << sp << endl; sp = "new string" ; cout << sp << endl ; } sp c o m p u t e r \0 str1 str2 c o m p u t e r \0

#include<iostream> using namespace std ; int main() 4.6.2 字符串访问 // 例4-22 串的赋值 #include<iostream> using namespace std ; int main() { char str1[10] = "computer" , str2[10] , *sp ; int i = 0 ; while( str1[i] ) { str2[i] = str1[i++]; } str2[i] = '\0' ; sp = str1 ; cout << str1 << endl << str2 << endl << sp << endl; sp = "new string" ; cout << sp << endl ; } sp c o m p u t e r \0 str1 str2 c o m p u t e r \0

#include<iostream> using namespace std ; int main() 4.6.2 字符串访问 // 例4-22 串的赋值 #include<iostream> using namespace std ; int main() { char str1[10] = "computer" , str2[10] , *sp ; int i = 0 ; while( str1[i] ) { str2[i] = str1[i++]; } str2[i] = '\0' ; sp = str1 ; cout << str1 << endl << str2 << endl << sp << endl; sp = "new string" ; cout << sp << endl ; } sp c o m p u t e r \0 str1 str2 c o m p u t e r \0 n e w s t r i g \0

#include<iostream> using namespace std ; int main() 4.6.2 字符串访问 // 例4-22 串的赋值 #include<iostream> using namespace std ; int main() { char str1[10] = "computer" , str2[10] , *sp ; int i = 0 ; while( str1[i] ) { str2[i] = str1[i++]; } str2[i] = '\0' ; sp = str1 ; cout << str1 << endl << str2 << endl << sp << endl; sp = "new string" ; cout << sp << endl ; } sp c o m p u t e r \0 str1 str2 c o m p u t e r \0 n e w s t r i g \0

#include<iostream> using namespace std ; int main() 4.6.2 字符串访问 // 例4-22 串的赋值 #include<iostream> using namespace std ; int main() { char str1[10] = "computer" , str2[10] , *sp ; int i = 0 ; while( str1[i] ) { str2[i] = str1[i++]; } str2[i] = '\0' ; sp = str1 ; cout << str1 << endl << str2 << endl << sp << endl; sp = "new string" ; cout << sp << endl ; } sp c o m p u t e r \0 str1 str2 c o m p u t e r \0 n e w s t r i g \0

#include<iostream> using namespace std ; int main() 4.6.2 字符串访问 // 例4-22 串的赋值 #include<iostream> using namespace std ; int main() { char str1[10] = "computer" , str2[10] , *sp ; int i = 0 ; while( str1[i] ) { str2[i] = str1[i++]; } str2[i] = '\0' ; sp = str1 ; cout << str1 << endl << str2 << endl << sp << endl; sp = "new string" ; cout << sp << endl ; } sp c o m p u t e r \0 str1 str2 c o m p u t e r \0 n e w s t r i g \0

4.6.3 字符串处理函数 cstring 函数 说明 strlen (Str ) 求串长。 strcpy_s( Des, Src ) 4.6.3 字符串处理函数 cstring 函数 说明 strlen (Str ) 求串长。 strcpy_s( Des, Src ) strcpy_s( Des, DesSize, Src ) 串复制。 DesSize指定Des的要求长度。 strcat_s( Des, Src ) strcat_s( Des, DesSize,Src ) 串连接。 strncat_s( Des, Src, Count ) strncat_s( Des, DesSize, Src，Count ) Count指定Src子串。 strcmp( Str1, Str2 ) strncmp( Str1, Str2, MaxCount ) 串比较。 MaxCount指定比较子串长度。

#include<cstring> #include<iostream> using namespace std; 4.6.3 字符串处理函数 //例4-23 测试字符串长度 #include<cstring> #include<iostream> using namespace std; int main() { char str1[] = "How do you do !"; char *str2 = "We write "; cout << "The string1 length is : " << strlen( str1 ) << endl; cout << "The string2 length is : " << strlen( str2 ) << endl; cout << "The string3 length is : " << strlen( "C++ program" ) << endl; }

#include<cstring> #include<iostream> using namespace std; 4.6.3 字符串处理函数 //例4-23 测试字符串长度 #include<cstring> #include<iostream> using namespace std; int main() { char str1[] = "How do you do !"; char *str2 = "We write "; cout << "The string1 length is : " << strlen( str1 ) << endl; cout << "The string2 length is : " << strlen( str2 ) << endl; cout << "The string3 length is : " << strlen( "C++ program" ) << endl; } 字符数组

#include<cstring> #include<iostream> using namespace std; 4.6.3 字符串处理函数 //例4-23 测试字符串长度 #include<cstring> #include<iostream> using namespace std; int main() { char str1[] = "How do you do !"; char *str2 = "We write "; cout << "The string1 length is : " << strlen( str1 ) << endl; cout << "The string2 length is : " << strlen( str2 ) << endl; cout << "The string3 length is : " << strlen( "C++ program" ) << endl; } 字符指针

#include<cstring> #include<iostream> using namespace std; 4.6.3 字符串处理函数 //例4-23 测试字符串长度 #include<cstring> #include<iostream> using namespace std; int main() { char str1[] = "How do you do !"; char *str2 = "We write "; cout << "The string1 length is : " << strlen( str1 ) << endl; cout << "The string2 length is : " << strlen( str2 ) << endl; cout << "The string3 length is : " << strlen( "C++ program" ) << endl; } 字符串常量

#include<cstring> #include<iostream> using namespace std; 4.6.3 字符串处理函数 //例4-24 复制字符串 #include<cstring> #include<iostream> using namespace std; int main() { char str1[20], *str2 ; str2=new char[20]; strcpy_s( str1, "computer world" ); strcpy_s( str2, 15, str1 ); cout << str1 << endl << str2 << endl << endl; }

#include<cstring> #include<iostream> using namespace std; 4.6.3 字符串处理函数 //例4-24 复制字符串 #include<cstring> #include<iostream> using namespace std; int main() { char str1[20], *str2 ; str2=new char[20]; strcpy_s( str1, "computer world" ); //把串常量复制到字符数组str1 strcpy_s( str2, 15, str1 ); cout << str1 << endl << str2 << endl << endl; } str1是字符数组

#include<cstring> #include<iostream> using namespace std; 4.6.3 字符串处理函数 //例4-24 复制字符串 #include<cstring> #include<iostream> using namespace std; int main() { char str1[20], *str2 ; str2=new char[20]; strcpy_s( str1, "computer world" ); //把串常量复制到字符数组str1 strcpy_s( str2, 15, str1 ); //把串str1复制到str2，要求长度15 cout << str1 << endl << str2 << endl << endl; } str2是字符指针 要求串长15

#include<cstring> #include<iostream> using namespace std; 4.6.3 字符串处理函数 //例4-24 复制字符串 #include<cstring> #include<iostream> using namespace std; int main() { char str1[20], *str2 ; str2=new char[20]; strcpy_s( str1, "computer world" ); //把串常量复制到字符数组str1 strcpy_s( str2, 15, str1 ); //把串str1复制到str2，要求长度15 cout << str1 << endl << str2 << endl << endl; }

#include<cstring> //例4-25 字符串连接 #include<iostream> 4.6.3 字符串处理函数 #include<cstring> //例4-25 字符串连接 #include<iostream> using namespace std; int main() { char str1[30], str2[10]; char *str3 = new char[30]; strcpy_s( str1, 30,"computer_" ); strcpy_s( str2, "world_" ); strcat_s( str1, "world_" ); cout << str1 << endl; strncat_s( str1,str2, 3 ); str3[0]='\0'; strncat_s( str3,30,str1,10); cout << str3 << endl; }

#include<cstring> //例4-25 字符串连接 #include<iostream> 4.6.3 字符串处理函数 #include<cstring> //例4-25 字符串连接 #include<iostream> using namespace std; int main() { char str1[30], str2[10]; char *str3 = new char[30]; strcpy_s( str1, 30,"computer_" ); strcpy_s( str2, "world_" ); strcat_s( str1, "world_" ); //把串常量添加到字符数组str1之后 cout << str1 << endl; strncat_s( str1,str2, 3 ); str3[0]='\0'; strncat_s( str3,30,str1,10); cout << str3 << endl; }

#include<cstring> //例4-25 字符串连接 #include<iostream> 4.6.3 字符串处理函数 #include<cstring> //例4-25 字符串连接 #include<iostream> using namespace std; int main() { char str1[30], str2[10]; char *str3 = new char[30]; strcpy_s( str1, 30,"computer_" ); strcpy_s( str2, "world_" ); strcat_s( str1, "world_" ); //把串常量添加到字符数组str1之后 cout << str1 << endl; strncat_s( str1,str2, 3 ); //把str2的3个字符添加到str1之后 str3[0]='\0'; strncat_s( str3,30,str1,10); cout << str3 << endl; }

#include<cstring> //例4-25 字符串连接 #include<iostream> 4.6.3 字符串处理函数 #include<cstring> //例4-25 字符串连接 #include<iostream> using namespace std; int main() { char str1[30], str2[10]; char *str3 = new char[30]; strcpy_s( str1, 30,"computer_" ); strcpy_s( str2, "world_" ); strcat_s( str1, "world_" ); //把串常量添加到字符数组str1之后 cout << str1 << endl; strncat_s( str1,str2, 3 ); //把str2的3个字符添加到str1之后 str3[0]='\0'; strncat_s( str3,30,str1,10); //把str1的10个字符添加到str3 cout << str3 << endl; }

#include<cstring> //例4-25 字符串连接 #include<iostream> 4.6.3 字符串处理函数 #include<cstring> //例4-25 字符串连接 #include<iostream> using namespace std; int main() { char str1[30], str2[10]; char *str3 = new char[30]; strcpy_s( str1, 30,"computer_" ); strcpy_s( str2, "world_" ); strcat_s( str1, "world_" ); //把串常量添加到字符数组str1之后 cout << str1 << endl; strncat_s( str1,str2, 3 ); //把str2的3个字符添加到str1之后 str3[0]='\0'; strncat_s( str3,30,str1,10); //把str1的10个字符添加到str3 cout << str3 << endl; }

//例4-26 用串比较函数查找指定串 #include<cstring> #include<iostream> 4.6.3 字符串处理函数 //例4-26 用串比较函数查找指定串 #include<cstring> #include<iostream> using namespace std; int main() { char *name[5] = { "LiHua", "HeXiaoMing", "ZhangLi", "SunFei", "ChenBao" }; char in_name[20]; int i, flag = 0; cout << "Enter your name: " ; cin >> in_name ; for( i = 0; i<5; i++ ) if ( strcmp( name[i], in_name ) == 0 ) { flag = 1; break; } if ( flag == 1 ) cout << in_name << " is in our class.\n"; else cout << in_name << " is not in our class.\n"; }

//例4-26 用串比较函数查找指定串 返回值 相等: 0 大于: 1 小于: -1 #include<cstring> 4.6.3 字符串处理函数 //例4-26 用串比较函数查找指定串 #include<cstring> #include<iostream> using namespace std; int main() { char *name[5] = { "LiHua", "HeXiaoMing", "ZhangLi", "SunFei", "ChenBao" }; char in_name[20]; int i, flag = 0; cout << "Enter your name: " ; cin >> in_name ; for( i = 0; i<5; i++ ) if ( strcmp( name[i], in_name ) == 0 ) { flag = 1; break; } if ( flag == 1 ) cout << in_name << " is in our class.\n"; else cout << in_name << " is not in our class.\n"; } 返回值 相等: 0 大于: 1 小于: -1

//例4-26 用串比较函数查找指定串 #include<cstring> #include<iostream> 4.6.3 字符串处理函数 //例4-26 用串比较函数查找指定串 #include<cstring> #include<iostream> using namespace std; int main() { char *name[5] = { "LiHua", "HeXiaoMing", "ZhangLi", "SunFei", "ChenBao" }; char in_name[20]; int i, flag = 0; cout << "Enter your name: " ; cin >> in_name ; for( i = 0; i<5; i++ ) if ( strcmp( name[i], in_name ) == 0 ) { flag = 1; break; } if ( flag == 1 ) cout << in_name << " is in our class.\n"; else cout << in_name << " is not in our class.\n"; }

#include <cstdio> int main() { char *s = new char[128]; 4.6.3 字符串处理函数 //例4-27 包含空格的字符串输入输出 #include <cstdio> int main() { char *s = new char[128]; gets_s( s,10 ); //输入字符串长度<10 puts( s ); delete []s; s = NULL ; } 头文件

char *gets_s( char * _Buf, size_t _Size ); 4.6.3 字符串处理函数 //例4-27 包含空格的字符串输入输出 #include <cstdio> int main() { char *s = new char[128]; gets_s( s,10 ); //输入字符串长度<10 puts( s ); delete []s; s = NULL ; } char *gets_s( char * _Buf, size_t _Size );

int puts( const char * _Str ); 4.6.3 字符串处理函数 //例4-27 包含空格的字符串输入输出 #include <cstdio> int main() { char *s = new char[128]; gets_s( s,10 ); //输入字符串长度<10 puts( s ); delete []s; s = NULL ; } int puts( const char * _Str );

#include <cstdio> int main() { char *s = new char[128]; 4.6.3 字符串处理函数 //例4-27 包含空格的字符串输入输出 #include <cstdio> int main() { char *s = new char[128]; gets_s( s,10 ); //输入字符串长度<10 puts( s ); delete []s; s = NULL ; }

小结 数组以线性关系组织对象。一个n维数组的每个元素是n-1维数组。 数组元素以下标表示它在数组中的位置，称为下标变量。 使用指针数组，可以管理复杂的对象，例如字符串、函数以及类对象。 数组占有一片连续的存储空间。数组名表示这片存储空间的首地址。 使用new和delete算符能够动态地申请和收回内存空间。 C++可以把字符指针作为“字符串变量”使用，实现对字符串的“名”访问。 string是C++预定义的类，它提供了对字符串更安全和方便的操作。 排序、查找、比较、复制等是数组的常用操作。

反馈: 隐私 反馈
About project: SlidePlayer 条款

© 2024 slidesplayer.com Inc. All rights reserved.