上机报告1（1 熟悉Visual C 6，2 数据类型、运算符、表达式、基本输入输出与结构控制，3 函数和数组）

一、 上机目的和要求

a. 实验一

1. 了解和使用Visual C++ 6.0集成开发环境；
2. 熟悉Visual C++ 6.0环境的基本命令和功能键，熟悉常用的功能菜单命令；
3. 学习完整的C++程序开发过程。
4. 了解C++语言的数据类型，包括基本数据类型和构造数据类型。
5. 掌握基本数据类型，包括整型、浮点型、字符型、布尔型和空值型。
6. 掌握C++的基本输入输出格式。
7. 学会使用C++的运算符和表达式。

b. 实验二

1. 了解C++语言中数据类型的意义。
2. 理解常用运行符的意义，C++语言表达式的运行规则。
3. 掌握C++的基本输入输出格式。
4. 掌握各种选择语句的使用。
5. 掌握各种循环语句的使用。
6. 掌握各种转向语句的使用。
7. 学会综合运用控制语句进行简单的编程。
8. 掌握中止语句和预处理语句。

c. 实验三

1. 掌握函数的定义，调用以及函数值的返回。
2. 掌握递归函数的定义与调用。
3. 掌握内联函数的定义与调用。
4. 掌握一维、二维数组的定义与使用。
5. 掌握数组在函数参数中的传递方式。
6. 掌握一维数组的排序，并用二维数组处理矩阵。

d. 五一作业

1. 撰写自己的英文个人简历（100个单词以上），将文本形成字符串。
   （1） 以标点符号（句号，问号，叹号）分成句子（子字符串），统计有多少个句子；
   （2） 统计文中有英文字母（a-z）频率（不区分大小写，a或A按一个字母统计）
2. 先用C实现一个工程，调试通过。
3. 再用C++的string类实现一个工程，调试通过。
4. （追加选做）chapter 6 第7、8题

二、 基本知识和原理

a. 实验一

1. Visual C++简介

Visual C++是Microsoft 公司的Visual Studio 开发工具箱中的一个C++程序开发包。Visual Studio 提供了一整套开发Internet 和Windows 应用程序的工具，包括Visual C++， Visual Basic，Visual FoxPro，Visual InterDev，Visual J++以及其他辅助工具，如代码管理工具Visual SourceSafe 和联机帮助系统MSDN。Visual C++包中除包括C++编译器外，还包括所有的库、例子和为创建Windows 应用程序所需要的文档。
从最早期的1.0 版本发展到6.0 版本，到最新的VC 2015，VC2017，VC2019版本，Visual C++已经有了很大的变化，在界面、功能、库支持方面都有许多的增强。6.0 版本在编译器、MFC 类库、编辑器以及联机帮助系统等方面都比以前的版本做了较大改进。Visual C++ 6.0一般分为三个版本：学习版、专业版和企业版，不同的版本适合于不同类型的应用开发。实验中可以使用这三个版本的任意一种。

2. C++程序的结构

一个C++程序有多个程序单位构成，每一个程序单位作为一个文件，编译系统分别对每个程序文件进行编译，然后连接起来形成可执行程序。
在一个程序单位中包含以下几部分：
声明区
主程序区
函数定义区（由函数首部和函数体组成），一个C++必须有一个（而且只能有一个）main函数。

3. C++数据类型和表达式

C++有多种数据类型，数据类型隐含着该类数据的表示、存储及处理规则。C++运算符丰富，使用十分灵活。用运算符和括号将运算对象（操作数）连接起来，构成表达式。表达式中混合运算式要注意运算符的优先级和结合性。此外，不同数据类型运算时，存在类型转换（隐式类型转换和强制类型转换）。

b. 实验二

1. C++语言中数据类型

2. 基本输入/输出

C++中有2个预定义的流对象：
（1）cin是标准输入流对象，键盘为标准设备；
（2）cout是标准输出流对象，显示器为标准设备；
“<<”和“>>”本来在C++中是被定义为左移位运算符和右移位运算符的，由于在iostream头文件中对它们进行了重载，使它们能用作标准类型数据的输入和输出运算符，所以，在出现它们的程序中必须用#include
如果想将“<<”和“>>”用于自己声明的类型的数据中，就不能简单地采用包含iostream头文件来解决，必须对“<<”和“>>”进行重载。

3. 结构控制

C++语言中结构化算法的基本控制结构有3种：顺序结构、选择结构和循环结构。另外还有多个转向语句，如break、continue、goto语句等。
（1）顺序结构
语句1
语句2
……
语句n+1
（2）选择结构
实现选择结构可用if和switch语句。
① 简单if选择语句
if(表达式)
{
语句组
}
当语句组织有一个语句时，可以省略大括号。
② 双重if选择语句
if(表达式)
{
语句组1
}
else
{
语句组2
}
③ 多重if选择语句
if(表达式)
{
语句组1
}
else if(表达式2)
{
语句组2
}
else if(表达式3)
{
语句组3
}
……
else
{
语句组n+1
}
④ switch语句
switch(表达式)
{
case 常量表达式1:语句组1;break;
case 常量表达式2:语句组2;break;
……
case 常量表达式3:语句组3;break;
default: 语句组n+1;break;
}
（3）循环结构
① while语句
while(表达式)
{
语句组
}
② do-while语句
do
{
语句组
}
while(表达式);
③ for语句
for(表达式1; 表达式2; 表达式3)
{
语句组
}
（4）break语句
break语句用于switch语句或循环语句中，其作用是跳出switch语句或内层循环，继续执行其后面的语句。
（5）continue语句
continue语句用于循环语句中，其作用是结束本次循环开始判断是否继续执行下一次循环。
（6）goto语句
goto语句是非结构化语句，其作用是使程序的执行流程跳转到语句标号所指定的语句。由于goto语句的使用会破坏程序结构，所以应该尽量少或不用。

c. 实验三

（一）函数

1. 函数的定义格式

<类型名><函数名>([<参数表>])
<函数体>

2. 函数的原型声明

在C++中，如果一个函数要调用另外一个函数，则需要在本函数(称为主调函数)定义之前将要被调用的函数事先声明。函数原型的声明形式是：
<类型><被调用函数名>([<形参表>]);

3. 函数的调用

函数调用的格式为:
函数名([<实参表>]);

4. 函数的参数

在定义函数时，C++语言用三种方式将函数的形式参数分别声明为值参数、地址参数和引用参数。
A.值参数
传递规则：直接将实参的值复制给形参。这种传递方式的特点是无论被调用函数如何改变形参,都不会对实参产生任何影响。
B.地址参数
传递规则：实参在向形参传递时复制的是实参的地址。这种传递方式的特点是形参的改变会对实参产生影响。
C.引用参数
传递规则：实参在向形参传递时复制的是实参的"别名"，这种传递方式的特点是形参的改变会对实参产生影响。
D.在C++中,函数在原型声明或定义时可以在形参表内预先给形参指定默认的值，这样的函数称为带默认值的函数，其形参表的一般形式为：
<类型><形参1>=<表达式1>,…,<类型><形参n>=<表达式n>

5. 函数的嵌套调用和递归调用

嵌套调用：在一个函数的执行过程中去调用另外一个函数处理相应任务的方法。
基本原则：被调用的函数必须提前定义，如果被调用的函数定义在主调函数之后，则必须在主调函数前的适当位置有被调函数的函数原型声明。

6. 内联函数

在一个函数的定义或声明前加上关键字inline就可以把该函数定义为内联函数。
使用内联函数需要注意以下几点：
（1）内联函数中不能含有任何循环语句以及switch和goto语句。
（2）内联函数的声明必须出现在内联函数第一次被调用之前。
（3）内联函数中不能声明数组。
（4）递归函数不能被定义为内联函数。

7. 函数的重载

在C++语言中允许定义多个同名函数，这个功能被称为函数重载。
需要注意的是重载函数的形参在个数或类型上必须不同，不能仅依靠函数的返回值类型来区别重载函数，必须从形参数上区别开来。

8.作用域

在C++中，作用域可以分为5种：函数原型作用域，函数作用域，块作用域，类作用域和文件作用域。

9.全局变量和局部变量

在函数内部或块内部声明的变量称为局部变量，它具有块作用域，即从它声明的那一点开始到这个声明所在的块或函数结束为止。
在一个程序文件中，在所有函数外部定义的变量称为全局变量，有时也称为全程变量、公用变量。全局变量作用域是文件作用域，即从定义变量的位置开始到本程序文件结束。

10.变量的存储类型和生命周期

在C++中，变量的存储类型分为4种：自动类型（auto），寄存器类型（register），外部类型（extern），静态类型（static）。用这4种类型说明的变量分别称为自动变量，寄存器变量，外部变量，静态变量。
生命周期是指一个标识符(变量，函数，类，对象等)从被创建开始到被释放为止的时间。

11.编译预处理

编译预处理是指在对源程序进行正常的编译之前，先对这些命令进行预处理，然后将预处理的结果和源程序一起再进行编译处理。C++提供的编译处理命令有：宏定义命令，文件包含命令和条件编译命令，这些命令均为"#"开头，以区别于语句。
（1）宏定义
不带参数的宏定义：不带参数的宏定义相对比较简单，如下：
#define 宏名 字符串(或数值)
带有参数的宏定义：在宏定义中允许宏名后带参数，如下：
#define 宏名(参数表) 字符串
（2）文件包含
预处理指令#include 称为文件包含指令。
#include 指令有两种书写形式：
第一种：#include <文件名>
第二种：#include “文件名”
（3）条件编译
条件编译指令有如下几种形式：
形式一：
#if 常量表达式1
程序段1
#elif常量表达式2
程序段2
……
#elif常量表达式n
程序段n
#else
程序段n+1
#endif

形式二：
#ifdef 标志符
程序段1
#else
程序段2
#endif
形式三：
#ifndef 标志符
程序段1
#else
程序段2
#endif

（二）数组

数组就是把一系列有序的相同类型的数据组合起来的数据集合，数组都有一个名字即数组名。数组中的每一个数据成为数组的元素。数组元素在数组中的位置由下标确定。根据数组元素下标的个数，数组分为一维数组和多维数组。当数组元素的数据类型为字符型时，该数组称为字符数组。

1.一维数组的定义与初始化赋值

（1）一维数组的定义
在使用数组前，必须对数组进行定义。一维数组的定义包括对数组名、数组元素的数据类型和个数的说明。一维数组的定义格式为:
{存储类型}<类型><数组名>[<常量表达式>];
（2）一维数组的初始化赋值
像普通变量一样，在数组定义的同时就可以对数组元素进行赋值。方法是从数组的第一个元素开始依次给出初值，形成一个初值表，表中各个初值之间用逗号分开，初值表用一对花括号包含起来。一维数组初始化赋值的方法有：
a.给数组的所有元素赋初值。
b.给数组的部分元素赋初值。
c.当把数组定义为全局变量或静态变量时，所有数组元素的初值均为0，当把数组定义为其他存储类型的局部变量时，数组元素没有确定的值，即其值是随机的。

2.一维数组在内存中的存储方式

当定义了一个数组之后，系统就为数组分配一串连续的存储单元，来依次存放各个数组元素。

3.一维数组元素的访问

数组必须先定义后使用。C++规定只能对数组中的元素进行访问，不能把整个数组作为一个整体使用。一维数组元素的访问形式:
<数组名>[<下标表达式>]
下标表达式的值就是被访问的数组元素的下标，其数据类型必须为整型。

4.二维数组的定义与初始化赋值

由两个或两个以上下标的数组元素所组成的数组称为多维数组。下面以二维数组为例子说明多维数组的定义和使用方法。
一维数组中的元素带有一个下标，而二维数组中的元素则带有两个下标。一维数组在逻辑上可以想象成一行长表，而二维数组在逻辑上可以想象成是由若干行，若干列组成的一张表格。
（1）二维数组的定义
{存储类型}<类型><数组名>[<常量表达式1>][<常量表达式2>];
（2）二维数组的初始化赋值
和一维数组一样，二维数组也可以进行初始化赋值。二维数组初始化赋值的方法有:
a.给数组的所有元素赋初值
b.给数组的部分元素赋初值
给数组的部分元素赋初值的方法与给数组的所有元素赋初值的方法类似。

5.二维数组在内存中的存储方式

虽然在逻辑上可以把二维数组看作是一张表格或者一个矩阵，但是在计算机中存储二维数组时，也是在内存中开辟一串连续的存储单元，依次存放各个数组元素。
C++中，是按行为主顺序存放二维数组各个数组元素的，即先存放第一行上的元素，再存放第二行上的元素，依次把各行上的元素存入一串连续的存储单元中。

6.二维数组元素的访问

二维数组元素的访问形式为:
<数组名>[<下标表达式1>][<下标表达式2>]
下标表达式1和下标表达式2的值就是被访问的数组元素的两个下标，其数据类型必须为整数。多维数组的定义和使用方法与二维数组类似。

d. 五一作业

C++ 大大增强了对字符串的支持，除了可以使用C风格的字符串，还可以使用内置的 string 类。string 类处理起字符串来会方便很多，完全可以代替C语言中的字符数组或字符串指针。
C++ 标准库提供了 string 类类型，支持上述所有的操作，另外还增加了其他更多的功能。比如：

append() – 在字符串的末尾添加字符
find() – 在字符串中查找字符串
insert() – 插入字符
length() – 返回字符串的长度
replace() – 替换字符串
substr() – 返回某个子字符串
string
string是一个C++类库中的一个类，它位于名称空间std中，因此必须使用using编译指令或者std::string来引用它。它包含了对字符串的各种常用操作，它较char的优势是内容可以动态拓展，以及对字符串操作的方便快捷，用+号进行字符串的连接是最常用的操作
char
char* 是指向字符串的指针(其实严格来说，它是指向字符串的首个字母)，你可以让它指向一串常量字符串。
const char*
该声明指出，指针指向的是一个const char类型，即不能通过当前的指针对字符串的内容作出修改
注意这里有两个概念：
char * const [指向字符的静态指针]
const char * [指向静态字符的指针]
前者const修饰的是指针，代表不能改变指针
后者const修饰的是char，代表字符不能改变，但是指针可以变，也就是说该指针可以指针其他的const char。

char[]
与char*与许多相同点，代表字符数组，可以对应一个字符串

三、 程序算法分析及实现（代码）（或问题解答）

a. 实验一

【实例1】使用整型数据。

#include 
using namespace std;
int main()
{
int i = 1;
short shCounter = 128;
long lgResult = i + shCounter;
cout<<"lgResult="<<lgResult<<endl;
system(“pause”);
}

【实例2】使用字符型数据。

#include 
using namespace std;
int main()
{
char chA = 'A';
char chB =66;
cout<<"chA = "<<chA<<endl;
cout<<"chB = "<<chB<<endl;
}

【实例3】使用C++的输入输出流。

#include 
using namespace std;
void main()
{
int a,b;
cin>>a>>b;
cout<<a<<endl;
cout<<b<<endl;
}

b. 实验二

【实例1】比较两个实数的大小，要求输出相等、大于、小于等情况。

本题练习的是用if语句编写多重选择程序，即if-else if-else结构。比较两个实数的大小，有3种可能结果。其关系表达式非常简单，方法也较多，除了if-else if-else结构，还可以用if-else的嵌套结构。

#include  
using namespace std;
int main()
{
	double x,y;
	cout<<"please inter two numbers:";
	cin>>x>>y;
	if(x>y)
		cout<<"x>y"<<endl;
	else if(x<y)
		cout<<"x<<endl;
	else
		cout<<"x=y"<<endl;
system(“pause”);
}

注意：C++的相等运算符是“= =”。
【实例2】实现两个整数的简单四则运算。
本题练习的是用switch语句编写多重选择程序，简单四则运算有加（+）、减（-）、乘（*）、除（/），我们可以设一个字符型变量，通过比较这个变量，选择相应运算。

#include  
using namespace std;
int main()
{
	int data1,data2;
	char op;
	cout<<"start calculation:";
	cin>>data1>>op>> data2;
	switch(op)
	{
		case '+':cout<<data1<<op<<data2<<"="<<data1+data2<<endl;break;
		case '-':cout<<data1<<op<<data2<<"="<<data1-data2<<endl;break;
		case '*':cout<<data1<<op<<data2<<"="<<data1*data2<<endl;break;
		case '/':cout<<data1<<op<<data2<<"="<<data1/data2<<endl;break;
		default: cout<<"wrong！"<<endl;
	}
}

注意：当程序输入不是“+”、“-”、“*”、“/”的时候，则显示“输入有错！”。实验人员可能输入整数时也可以运行，此时注意此数据类型的转换。

【实例3】用while语句编写程序，求自然数50至100之和。

本题练习的是用while语句编写程序。可用累加算法，累加过程是一个循环过程。

#include  
using namespace std;
int main()
{
	int i=50,sum=0;
	while(i<=100)
	{
		sum+=i;
		i++;
	}
	cout<<"from 50 to 100 sum is:"<<sum<<endl;
}

注意：注意累加运算的起点和终点，避免遗漏和重复。
【实例4】用do-while语句编写程序，求自然数50至100之和。
本题练习的是用do-while语句编写程序。它与while循环语句的区别是do语句必需至少执行一次循环体，而while循环可能一次都没有执行就跳出循环。

#include  
using namespace std;
int main()
{
	int i=50,sum=0;
	do
	{
		sum+=i;
		i++;
	}while(i<=100);
	cout<<" from 50 to 100 sum is:"<<sum<<endl;
}

注意：do-while语句中，while行结束出有分号“；”，不要遗漏。

【实例5】用for语句编写程序，输入一个整数，求出它所有的因子。

本题练习的是用for语句编写循环程序。所谓正数i的因子是指所有能够整除i的整数。可以通过穷举法，对1~i之间的全部整数进行判断。

#include  
using namespace std;
int main()
{
int i,j;
cout<<”please inter the integer:”;
cin>>i;
cout<<”number”<<i<<”have element：”<<endl;
for(j=1;j<i;j++)
		if(i%j==0)
			cout<<j<<”  ”;
cout<<endl;
}

注意：for语句的下一行是循环体，如果循环体有多行语句，应使用大括号“{}”。

【实例6】用continue语句编写程序，输入10个实数，求出其中正数之和。

本题练习的是用continue语句编写程序。continue语句只能用在循环语句的循环体中结束本次循环，接着在判断是否执行下一次循环。在输入得10个实数中，可能有负数。可以通过if语句来判断正负；如果为负数就结束这次循环，如果为正数就累加求和。

#include  
using namespace std;
int main()
{
	const int N=10;
float num,sum=0;
cout<<” Please enter 10 real numbers:”;
for(int i=0;i<N;i++)
{
		cin>>num;
		if(num<0)
			continue;
		sum+=num;
}
cout<<” The sum of positive numbers is:”<<sum<<endl;
}

注意：continue语句只能用在循环语句的循环体内，用来结束本次循环，不能用在switch语句中。

c. 实验三

【实例1】从键盘输入两个任意整数，实现值参数传递调用。

#include 
using namespace std;
void swap(int &x,int &y)
{
	int temp;
	temp = x;
	x=y;
	y=temp;
}
int main()
{
	int a,b;
	cout<<"please input two integer numbers:"<<endl;
	cin>>a>>b;
	swap(a,b);
	cout<<"after function called"<<"a="<<a<<","<<"b="<<b<<endl;
}

要求：
(1) 被调用函数定义的位置；
(2) 被调用函数的调用方法，尤其注意形式参数和实际参数的区别；
体会值参数的传递规则；

【实例2】编写程序，计算键盘上输入的某个正整数的阶乘并输出。

#include 
using namespace std;
long int fac(int n);
int main()
{
	int n;
	cout<<"input a positive integer:";
	cin>>n;
	long fa=fac(n);
	cout<<n<<"!="<<fa<<endl;
}
long fac(int n)
{
	long int q;
	if (n==0 || n ==1)
	{
		q=1;
	}
	else
	{
		q=n*fac(n-1);
	}
	return q;
}

【实例3】某小组有10个学生进行了数学考试，求他们成绩的平均分，最高分和最低分。

题目分析：求N个数的平均值的方法是，求得N个数累加的和之后，并保存在变量SUM中，然后将累加和SUM除以数据个数N，即可求得N个数的平均值。求N个数中最大值的方法是，首先设变量MAX，存放第1个数，然后将余下的数按次序分别与MAX进行比较，若某一个数大于MAX，则将其值赋给MAX，若某一个数小于MAX，则MAX的值不变，当余下的数都比较完后，MAX中存放的就是N个数中的最大的值。求N个数中的最小值的方法与求N个数中的最大值的方法类似：

#include 
using namespace std;

const int N = 10;

int Max(int a[]);
int Min(int a[]);
int average(int a[]);

int main()
{
	int a[N];
	cout<<"input the scores:";
	for (int i = 0; i < N;i++)
		cin >> a[i];

	int ave, max, min;

	ave = average(a);
	max = Max(a);
	min = Max(a);

	cout << "average score " << ave << " max score " << max << " min score " << min << endl;
}
int average(int a[])
{
	int sum=0;
	for (int i = 0; i < N;i++)
		sum += a[i];
	return (sum / N);
}
int Max(int a[])
{
	int temp=a[0];
	for (int i = 0; i < N;i++)
	if(temp<=a[i])
		temp = a[i];
	return temp;
}
int Min(int a[])
{
	int temp=a[0];
	for (int i = 0; i < N;i++)
	if(temp>=a[i])
		temp = a[i];
	return temp;
}

【实例4】某班有10个学生，进行了数学考试，现要求将数学成绩按由低到高的顺序排序。

分析：排序是指将一组无序的数据按从小到大（升序）或从大到小（降序）的次序重新排列。
程序如下：

#include 
#include 
using namespace std;
#define N 10
int main()
{  
	int a[N],temp;
	int i,j;
	cout<<"Input score:";
	for (i=0;i<=N-1;i++)
		cin>>a[i];
	for (i=1;i<=N-1;i++)
		for (j=0;j<=N-i-1;j++)
			if (a[j]>a[j+1])
			{   
				temp=a[j];
				a[j] =a[j+1];
				a[j+1]=temp;
			}
	for (i=0;i<=N-1;i++)
		cout<<setw(3)<<a[i];
	cout<<endl;
}

【实例5】假定在一维数组a[10]中保存着10个整数：42,55,73,28,48,66,30,65,94,72。编写程序，从中顺序查找出具有给定值x的元素，若查找成功则返回该元素的下标位置，否则查找失败返回-1。

题目分析：假定把从一维数组中顺序查找的过程单独用一个函数模块来实现，把调用该函数进行顺序查找通过主函数来实现，则整个程序如下：

#include 
using namespace std; 
const int N=10;       
int a[N]={42,55,73,28,48,66,30,65,94,72};
int SequentialSearch(int x) 
{ 
for (int i = 0; i < N;i++)
    if(x==a[i])
        return i;
    return -1;
 
} 
int main() 
{
int x1=48,x2=60,f; 
f=SequentialSearch(x1); 
if(f==-1)
cout<<"find"<<x1<<"fail!"<<endl;
else
cout<<"find"<<x1<<"success!"<<" Under-bid is"<<f<<endl;
f=SequentialSearch(x2);  
if(f==-1)
cout<<"find"<<x2<<"fail!"<<endl;
else
cout<<"find"<<x2<<"success!"<<" Under-bid is"<<f<<endl;
}

【实例6】将一个二维数组的行和列元素互换，形成另一个二维数组，即数组的转置运算。

例如:

程序为:

#include 
#include 
using namespace std;
int main()
{
int a[3][4] = {{1,2,3,4},{5,6,7,8},{9,10,11,12}};
int b[4][3];
    for (int i =0;i<3;i++)
    {
        for (int j = 0;j<4;j++)
        {
            b[j][i] = a[i][j];
        }
    }
    for (int i =0;i<4;i++)
    {
        for (int j = 0;j<3;j++)
        {
            cout<< b[i][j];
        }
        cout << "\n";
    }
}

d. 五一作业

一篇英语文章即可

C Programming Language

# include 
# include 
int string_account(char* str);
void abc_account(char* str);
int j;
int abc[26]={0};
int main(void)
{
   char str[1000];
   int i,n,sum=0;
   scanf("%[^\n]",str);
   j=strlen(str);
	n=string_account(str);  
   abc_account(str);
   for(i=0;i<26;i++)
	   sum+=abc[i];
   printf("Total have %d stings\n",n);
   for(i=0;i<26;i++)
    printf("There are %d '%c',are %f%c\n",abc[i],'a'+i,(0.1*abc[i]/sum)*100,'%');
   return 0;
}

int string_account(char* str)
{
	int i,k=0;
	char *p;
	p=str;
	for(i = 0; i < j ; i++)
	{
		p++;
		if((*p)=='.' || (*p)=='?' || (*p)=='!')
			k++;
	}
	return k;
}
void abc_account(char* str)
{
	int i,a1;
	char *p;
	p=str;
	for(i=0;i<j;i++)
	{
			switch(*(p++))
		{
			case 'a' : case 'A':
				abc[0]++;
				break;
			case 'b' : case 'B':
				abc[1]++;
				break;
			case 'c' : case 'C':
				abc[2]++;
				break;
			case 'd' : case 'D':
				abc[3]++;
				break;
			case 'e' : case 'E':
				abc[4]++;
				break;
			case 'f' : case 'F':
				abc[5]++;
				break;
			case 'g' : case 'G':
				abc[6]++;
				break;
			case 'h' : case 'H':
				abc[7]++;
				break;
			case 'i' : case 'I':
				abc[8]++;
				break;
			case 'j' : case 'J':
				abc[9]++;
				break;
			case 'k' : case 'K':
				abc[10]++;
				break;
			case 'l' : case 'L':
				abc[11]++;
				break;
			case 'm' : case 'M':
				abc[12]++;
				break;
			case 'n' : case 'N':
				abc[13]++;
				break;
			case 'o' : case 'O':
				abc[14]++;
				break;
			case 'p' : case 'P':
				abc[15]++;
				break;
			case 'q' : case 'Q':
				abc[16]++;
				break;
			case 'r' : case 'R':
				abc[17]++;
				break;
			case 's' : case 'S':
				abc[18]++;
				break;
			case 't' : case 'T':
				abc[19]++;
				break;
			case 'u' : case 'U':
				abc[20]++;
				break;
			case 'v' : case 'V':
				abc[21]++;
				break;
			case 'w' : case 'W':
				abc[22]++;
				break;
			case 'x' : case 'X':
				abc[23]++;
				break;
			case 'y' : case 'Y':
				abc[24]++;
				break;
			case 'z' : case 'Z':
				abc[25]++;
				break;
			}
	}
}

C++ Programming Language

#include
#include
#include
using namespace std;
int main(void)
{
    string str;
    int i=0,k = 0,j,sum=0;
   getline(cin,str);
    j=str.length();
   while ((i = str.find('.', i)) < str.length())
	{
		k++;
		i++;
	}
	i = 0;
	while ((i = str.find('!', i)) < str.length())
	{
		k++;
		i++;
	}
	i = 0;
	while ((i = str.find('?', i)) < str.length())
	{
		k++;
		i++;
	}
	 cout<<"Total have " << k <<" stings"<<endl;
	 for (int n=0; n < 26;n++)
	 {
		 i = 0;
		 k = 0;
		 while ((i = str.find('a'+n, i)) < str.length())
		 {
			 k++;
		     i++;
		 }
		 sum += k;
		 i = 0;
		 k = 0;
		 while ((i = str.find('A'+n, i)) < str.length())
		 {
			 k++;
		     i++;
		 }
		  sum += k;
		  cout << "There have " << sum <<' ' <<char('a' + n) << endl;
		  sum = 0;
	 }
		 system("pause");
}

Chapter 7

#include
#include
#include
using namespace std;
int main(void)
{
    string str;
    int i=0,num = 0,sum=0;
    getline(cin,str);
   while ((i = str.find('.', i)) < str.length())
    str.erase(i, 1 );
   i = 0;
   while ((i = str.find(',', i)) < str.length())
       str.erase(i, 1);
   i = 0;
   while ((i = str.find('!', i)) < str.length())
       str.erase(i, i + 1);
   i = 0;
   while ((i = str.find('?', i)) < str.length())
       str.erase(i, i + 1);
   i = 0; 
   while ((i = str.find(' ', i)) < str.length())
	{
		num++;
		i++;
	}
	 for (int i=0; i < str.length();i++)
	 {
		 sum += (str.find(' ', i)-i);
         i = str.find(' ', i);
     }
     cout <<"The average length of words is "<< sum/num << endl;
    system("pause");
}

Chapter 8

#include
#include
#include
using namespace std;
int main(void)
{
    string str;
    int min, max;
    int i=0,k=0;
   cin >> min;   
    if(min<20)
    cin >> max;
    else
        max = 100;
    cin.ignore();
    getline(cin,str);
    while ((i = str.find('.', i)) < str.length())
        str.erase(i, 1);
    i = 0;
    while ((i = str.find(',', i)) < str.length())
        str.erase(i, 1);
    i = 0;
    while ((i = str.find('!', i)) < str.length())
        str.erase(i, i + 1);
    i = 0;
    while ((i = str.find('?', i)) < str.length())
        str.erase(i, i + 1);
	 for (int i=0; i < str.length();i++)
	 {
         if((str.find(' ', i) -i)>=min && max>=(str.find(' ', i) -i)) 
               cout <<str.substr(i,str.find(' ', i) -i) <<'\n'<< endl;
         i = str.find(' ', i);
     }
    system("pause");
}