C语言08字符串 & 预处理 & 结构体

by admin on 2020年1月20日

/*作业8-5:输入一字符串,将该字符串中第m个字符初叶的全套字符复制作而成另贰个字符串。
 m由客户输入,值小于字符串的长短。必要编辑一个函数mcopy(char *s , int
m)来完成。
 */n
# include “stdio.h”
# include “string.h”
void mcopy(char *s , int m);
int main(void )
{
 int m;
 char str1[100],str2[100];
 puts(“please input a string:”);
 gets(str1);
 printf(“please input m:”);
 scanf(“%d”,&m);
    mcopy(str1,m);
    return 0;
}
void mcopy(char *s , int m)
{
 char str1[100],str2[100];
 int i,n;
 n=strlen(str1);
 for(i = 0; i < n-m; i++)
 str2[i]=str1[i+m];
 puts(str2);
}

C语言08字符串 & 预处理 & 结构体

业已在软通重力写过的算法题当中有一小部分是参照互连网的素材,未来拿出来给大家享用!
第3章 调节语句

类型支付中字符串模型创建

strstr的while dowhile模型

//int cltClient_rev(void *handle, unsigned char *buf, int *buflen)

//不要相信别人给你传送的内存地址是可用的

int getCout(char *str, char *substr, int *count)

{

int rv = 0;

char *p = str;

int ncout = 0;

if (str==NULL || substr== NULL || count==NULL)

{

rv = -1;

printf("func getCout()check (str==NULL || substr== NULL || count==NULL) err:%d n" , rv);

return rv;

}

do

{

p = strstr(p, substr);

if (p == NULL) //没有找到则跳出来

{

break;

}

else

{

ncout++;

p = p + strlen(substr);

}

} while (*p != ‘’);

//fuzhi

*count = ncout;

printf("ncout:%dn", ncout);

return rv;

}

void main36()

{

char *p = "abcd1111abcd222abcd3333";

int ncout = 0;

while (p = strstr(p, "abcd"))

{

p = p + strlen("abcd");

ncout ++;

if (*p == ‘’)

{

break;

}

}

printf("ncout:%dn", ncout);

system("pause");

}

两头堵模型(两种写法)

//求去掉空格

//int trimSpaceStr2(char *p, unsigned char *buf2, int *buf2len)

int trimSpaceStr2( char *p, char *buf2)

{

int ret = 0;

int ncount = 0;

int i, j;

i = 0;

j = strlen(p) -1;

while (isspace(p[i]) && p[i] != ‘’)

{

i++;

}

while (isspace(p[j]) && j>0 )

{

j–;

}

ncount = j – i + 1;

//

strncpy(buf2, p+i, ncount);

buf2[ncount] = ‘’;

return ret;

}

//求去掉空格

//int trimSpaceStr2(char *p, unsigned char *buf2, int *buf2len)

//不要轻易去改变指针输入特性中in内存块的内存。。。。

int trimSpaceStr2_notgood( char *p)

{

int ret = 0;

int ncount = 0;

int i, j;

i = 0;

j = strlen(p) -1;

while (isspace(p[i]) && p[i] != ‘’)

{

i++;

}

while (isspace(p[j]) && j>0 )

{

j–;

}

ncount = j – i + 1;

//

strncpy(p, p+i, ncount);

p[ncount] = ‘’;

return ret;

}

字符串反转模型

void main51()

{

char p[] = "abcde";

char c ;

char *p1 = p;

char *p2 = p + strlen(p) -1;

while (p1 < p2)

{

c = *p1;

*p1 = *p2;

*p2 = c;

++p1;

–p2;

}

printf("p:%s n", p);

system("pause");

}

 

/*
1、打字与印刷出具备的“姚女子花剑数”。所谓“水仙花数”是指二个四位数,其各位数字立方和分外该数本人。比方,153是大器晚成天葱数,因为153
= 13 + 53 + 33。 */
#include<iostream.h>
void main()
{
int i, a=0, b=0, c=0;
for(i=100;i<1000;i++)
{
a=i%10;
b=i/10%10;
c=i/100%10;
if(a*a*a+b*b*b+c*c*c==i)
cout<<“i=”<<i<<endl;
}
}

五个帮扶指针变量挖字符串

int getKeybyValue(char *pKeyValude, char *pKey, char *pValude)

{

char rv = 0;

char *p = NULL;

if (pKeyValude==NULL )

{

rv = -1;

printf("func getKeybyValue() err:%d pKeyValude n", rv);

return rv;

}

if ( pKey==NULL )

{

rv = -1;

printf("func getKeybyValue() err:%d pKey=NULL n", rv);

return rv;

}

if ( pValude==NULL )

{

rv = -1;

printf("func getKeybyValue() err:%d pValude n", rv);

return rv;

}

//1 在pKeyValude中查找是否有关键字pKey

p = strstr(pKeyValude, pKey);

if (p == NULL)

{

rv = -1;

printf("func getKeybyValue() err:%d 查找没有关键字pKey n", rv);

return rv;

}

p = p + strlen(pKey); //为下一次检索做准备

//2 有没有=

p = strstr(p, "=");

if (p == NULL)

{

rv = -2;

printf("func getKeybyValue() err:%d 查找没有= n", rv);

return rv;

}

p = p + 1; //为下一次提取valude做准备

//3 提取按照要求的valude

rv = trimSpaceStr03(p, pValude);

if (rv != 0)

{

printf("func trimSpaceStr03() err:%d n", rv);

return rv;

}

return rv;

}

/*
2、叁个数假使适逢其会等于它的因子之和,那么些数就叫做“完数”。举例,6的因子为1、2、3,而6
= 1 + 2 +
3,因而6是“完数”。编制程序序寻觅1000之内的富有完数,并按下边包车型地铁格式输出其因子:
6 -〉1,2,3 */
#include<iostream.h>
void main()
{
int i,j,sum=0,a[50],k,t;
for(i=1;i<=1000;i++)
{
sum=0;
        for(j=1;j<i;j++)
{
if(i%j==0)
{
sum+=j;
a[k++]=j;
}
}
t=k;
if(sum==i)
{
cout<<i<<“->”;
for(k=0;k<t;k++)
{
cout<<a[k];
if(k<t-1)cout<<“,”;
}
cout<<endl;
}
    k=0;
}
}

指针作函数参数输入模型


/*
3、求Sn=a+aa+aaa+…+aa…a之值,此中a是多个数字。举例:2+22+222+…+22222(那个时候n=5),n由键盘输入。*/
#include<iostream.h>
void main()
{
double a,sn=0.0,sum=0.0;
int n,i;
cout<<“please input a number”;
cin>>a;
    cout<<“please input n number”;
cin>>n;
sn=a;
sum=a;
    for(i=2;i<=n;i++)
    {
sum=sum*10+a;
sn+=sum;
    }
cout<<“Sn=”<<sn<<endl;
}

字符串

1.字符串幼功:

#include “stdlib.h”
#include “stdio.h”
#include “string.h”

//int * char *
//c语言里面未有字符串那连串型。。。。。
//通过字符数组来模拟字符串
//C风格字符串是以零结尾的字符串
//
void main11()
{
//字符数组开首化
//钦点长度 假若定义的长度剩余部分补充0
char buf1[100] = {‘a’, ‘b’, ‘c’};
//不钦定长度
char buf2[] = {‘a’, ‘b’, ‘c’};
char buf3[] = {‘a’, ‘b’, ‘c’,’’};

//通过字符串早先化字符数组 并且增添
char buf4[] = “abcdefg”;

printf(“%sn”, buf4 );

system(“pause”);
}

//sizeof
void main12()
{
//字符数组起初化
//内定长度 倘使定义的尺寸剩余部分补充0
char buf1[100] = {‘a’, ‘b’, ‘c’};
//不钦定长度
char buf2[] = {‘a’, ‘b’, ‘c’};
char buf3[] = {‘a’, ‘b’, ‘c’,’’};

//通过字符串早先化字符数组 何况扩张
char buf4[] = “abcd”;

printf(“%sn”, buf4 );
//注意sizeof是对数组类型举办高低衡量 包罗了
printf(“sizeof(buf4): %dn “, sizeof(buf4));
//strlen是求字符串的尺寸不满含
printf(“strlen(buf4): %d n”, strlen(buf4));
system(“pause”);
}

//操作数组的艺术
//下标法和指针法
void main()
{
int i = 0;
char *p = NULL;
//通过字符串初步化字符数组 况兼增加
char buf4[] = “abcd”;

for (i=0; i {
printf(“%c”, buf4[i]); //p[]
}
//[] *的本色到底是怎么?
//*p 是大家程序猿手工业的(突显)去行使直接赋值
//【】 只可是是,c/c++ 编写翻译器帮大家做了七个*p的操作。。。。。。
// buf4[i]======> buf4[0+i] ====> *(buf4+i)
//===*(buf4+i) –> bu4[i];

printf(“n”);
p = buf4;
for (i=0; i {
printf(“%c”, *(p+i)); //*p
}
system(“pause”);
}

2.自定义字符串拷Becky本模型

#include “stdlib.h”
#include “stdio.h”
#include “string.h”

//自定义:字符串copy函数,完结字符串from ,到to的copy
void copy_str1(char *from, char *to)
{
for (; *from!=’’; from++, to++)
{
*to = *from;
}
*to = ‘’;
}
void copy_str2(char *from, char *to)
{
while(*from!=’’)
{
*to = *from;
from++;
to++;
}
*to = ‘’;
}

//++优先级高,可是++是后缀++
//所以先实行*to = *from; 再 from++; to ++from++;
void copy_str3(char *from, char *to)
{
while((*to++ = *from++))
{
;
}
}

void main()
{
//输入:
//在主调里函数分配内部存款和储蓄器
char *p = “abcdefg”;
char p2[100] ;//char *p2 = NULL;
//在被调函数里应用内部存款和储蓄器
copy_str3(p, p2);//strcpy(p2, “abcdeeg”);
//输出:
printf(“p2:%sn”, p2);
system(“pause”);
}

¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥
看到一级指针,要去分辨指针的输入输出本性 ¥
指南针的输入天性:在主调函数里面分配内部存款和储蓄器,在被调用函数里面使用 ¥
指南针的输出脾性:在被调用函数里面分配内部存款和储蓄器,主倘诺把运算结果甩出来 ¥
¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥¥

3.种类支付字符串模型(此处为指针输入性情)

//char *p = “abcd1111abcd222abcd3333” 请你寻找字符串abcd出现的次数
//供给1:请自身定义一个接口(函数),并促功效益;70分
//要求2:编写测验用例。30分
/*
//输入:要探寻的字符串
待查找的子串
输出的结果*/
//接口提醒:int cltClient_rev(void *handle, unsigned char *buf, int
*buflen)

#include
#include
#include

//1级指针作函数参数(形参),用于修正0级指针(实参)
int getCout(char *str, char *substr, int *count)
{
int rv = 0;//用于出口检查和函数重返
char *p = str;//定义贰个指针,用于收纳形参地址
int ncout = 0;//用于计数
//不能相信外人传过来的地址就一定会将可用,需作安检
if (str==NULL || substr== NULL || count==NULL)
{
rv = -1;//地址不可用
printf(“func getCout()check err:%d n” , rv);
return rv;
}

do
{
p = strstr(p, substr卡塔尔(قطر‎;//此处调用的是库函数
if (p == NULL卡塔尔国 //未有找到则跳出来
{
break;
}
else
{
ncout++;//找到了就,计数加1
p = p + strlen(substrState of Qatar;//地址向后活动待查字符串个长度
}

} while (*p != ‘’卡塔尔(قطر‎;//指标字符串遍历完毕就得了循环

*count = ncout;//取实参地址直接纠正实参
printf(“ncout:%dn”, ncout);

return rv;//函数重临(int类型卡塔尔(قطر‎
}

void main()
{
int ret = 0;//用于收纳接口函数的重返值
int ncout = 0;//用于计数(第4个参数)
//输入:在主调函数里分配内部存款和储蓄器
/*对象字符串(第3个参数)*/
char *p = “abcd1111abcd222abcd3333”;//分配了内部存款和储蓄器,可拿到计数值
//char *p = NULL;//未有分配内部存款和储蓄器,未有计数值
/*待查字符串(第3个参数)*/
char *subp = “abcd”;
//输出:在被调函数里使用内部存款和储蓄器
ret = getCout(p, subp, &ncout);
//安检
if (ret != 0)
{
printf(“func getCout() err:%d n”, ret);
return ;
}
printf(“coutn:%d n”, ncout);
system(“pause”);

}
//下面那样的代码特别不OK!!!
void main01()
{
char *p = “abcd1111abcd222abcd3333”;
int ncout = 0;
while (p = strstr(p, “abcd”))
{
p = p + strlen(“abcd”);
ncout ++;
if (*p == ‘’)
{
break;
}
}
printf(“ncout:%dn”, ncout);
system(“pause”);
}

4.五头堵模型

#include “stdio.h”
#include “stdlib.h”
#include “string.h”
//不成熟的做法
void main01()
{
int count = 0;
int i = 0, j = 0;

char *p = ” abcd “;
j = strlen(p) -1;

while (isspace(p[i]) && p[i] != ‘’)
{
i++;
}

while (isspace(p[j]) && j>0)
{
j–;
}
count = j-i +1;

printf(“count:%d”, count);

system(“pause”);
}

//一流指针的输入模型,未有内部存款和储蓄器就从未指针

/*int trimSpace_很不ok的做法(char *mybuf)
{
int count = 0;
int i = 0, j = 0;
char *p = mybuf;
j = strlen(p) -1;
while (isspace(p[i]) && p[i] != ‘’)
{
i++;
}
while (isspace(p[j]) && j>0)
{
j–;
}
count = j-i +1;
printf(“count:%d”, count);
//void * __cdecl memcpy(void *, const void *, size_t);
memcpy(mybuf, mybuf+i, count);
mybuf[count] = ‘’;
return 0;
//system(“pause”);
}
*/

//日常处境下不要改善输入的内部存款和储蓄器块的值

int trimSpace_ok(char *mybuf, char *outbuf)
{//此函数去掉字符串前后空格
int count = 0;
int i = 0, j = 0;

char *p = mybuf;//定义三个指南针选拔形参地址
j = strlen(p) -1;
//isspace(卡塔尔(قطر‎函数用于检查测验字符串是不是为空
while (isspace(p[i]) && p[i] != ‘’)
{
i++;
}

while (isspace(p[j]) && j>0)
{
j–;
}
count = j-i +1;

printf(“count:%dn”, count);
//void * __cdecl memcpy(void *, const void *, size_t);
memcpy(outbuf, mybuf+i, count);
outbuf[count] = ‘’;
return 0;
}

void main()
{
int ret = 0;//用于检查和选择函数重临至
char *p = NULL;
char buf2[100];

//对于字符串分配内全体三种艺术,能够在堆、栈、全局区(常量区),
//你要掌握你的内部存款和储蓄器是怎么分配的
char *buf = ” abcd11111abcd2222abcdqqqqq “; //常量区
//char buf[] = ” abcd11111abcd2222abcdqqqqq “;//栈

/*很不OK的做法
ret = trimSpace(buf);
if (ret != 0)
{
printf(“func trimSpace() err:%dn”, ret);
return ;
}
*/

ret = trimSpace_ok(buf, buf2);
if (ret != 0)
{
printf(“func trimSpace() err:%dn”, ret);
return ;
}
printf(“buf2:%s n”, buf2);
system(“pause”);

}

5.字符串反转模型

#include “stdlib.h”
#include “stdio.h”
#include “string.h”

void main()
{
char p[] = “abcde”;//分配内部存款和储蓄器
char c ;
char *p1 = p;//指向字符串头
char *p2 = p + strlen(p卡塔尔 -1;//指向字符串尾

while (p1 < p2)//如果p1
{
c = *p1;
*p1 = *p2;
*p2 = c;
++p1;
–p2;//++、–可写到交流语句中
}
printf(“p:%s n”, p);
system(“pause”);

}

6.八个帮扶变量挖字符串

/*
有贰个字符串契合以下特点(”abcdef,acccd,eeee,aaaa,e3eeeee,sssss,”;)
务求写八个函数(接口),输出以下结果:
1) 以逗号分割字符串,产生二维数组,并把结果传到;
2) 把二维数组行数运算结果也传播。
strchr(“aa,aa”,’,’ );

请本身定义一个接口(函数)。
需求1:能科学发挥功用的须要,定义出接口(函数)(30分);
渴求2:精确贯彻接口(函数),并达成效益(40分);
务求3:编写正确的测量检验用例。(30分)。
*/
//abcdef,acccd,eeee,aaaa,e3eeeee,sssss,
/*
abcdef
acccd
eeee,
aaaa,
e3eeeee,
sssss,
*/

#include “stdio.h”
#include “string.h”
#include “stdlib.h”

int spitString(const char *buf1, char c, char buf[10][30], int
*num)
{
int ret = 0;
char *p = NULL;
char *pTmp = NULL;
int ncount = 0;
if (buf1==NULL || num==NULL)
{
return -1;
}
//步骤1 早先化条件 pTmp,p都推行检索的上马
p = buf1;
pTmp = buf1;
do
{
//步骤2 strstr strchr,会让p后移 在p和pTmp之间有叁个差值
p = strchr(p, c);
if (p == NULL卡塔尔国 //没有找到则跳出来
{
break;
}
else
{
//挖字符串
strncpy(buf[ncount], pTmp, p-pTmp);
buf[ncount][p-pTmp] = ‘’;

ncount++;

//步骤3 让p和pTmp重新初叶化,到达检索的尺度
pTmp = p = p + 1;
}

} while (*p != ‘’);
//printf(“ncout:%dn”, ncount);
*num = ncount;
return ret;
}
void main()
{
int ret = 0, i = 0;
const char *buf1 = “abcdef,acccd,eeee,aaaa,e3eeeee,sssss,”;
char c = ‘,’;
char buf[10][30];
int num = 0;
ret = spitString(buf1, c, buf, &num);
if (ret != 0)
{
printf(“func spitString() err:%dn”, ret);
return ret;
}

for (i=0; i {
printf(“%sn”, buf[i]);
}

system(“pause”);
}

7.二级指针第意气风发种内部存款和储蓄器模型模型(指针数组):

在栈中的风流倜傥维数组保存的地址指向常量区分配的内部存款和储蓄器

#include “stdio.h”
#include “stdlib.h”
#include “string.h”
//二级指针作函数参数订正一流指针的值
int printfArr(char **ArrayStr, int iNum)
{
int i = 0;
for (i=0; i {
printf(“%s n”, ArrayStr[i]);
}
return 0;
}

int sortArrayStr(char **ArrayStr, int iNum)
{
int i = 0, j = 0;
char *tmp =
NULL;//用于沟通是的近日变量,由于C语法规定,必得在言语前定义
//排序
for (i=0; i {
for (j=i+1; j {
if (strcmp(ArrayStr[i],ArrayStr[j]) > 0)
{
//一流指针调换(数组成分)
tmp = ArrayStr[i];
ArrayStr[i] = ArrayStr[j];
ArrayStr[j] = tmp;
}
}
}
return 0;
}

//二级指针第意气风发种内部存款和储蓄器模型
void main()
{
//分配内部存款和储蓄器(常量区,不可改革)
char *ArrayStr[] = {“ccccc”, “aaaa”, “bbbb”,”11111″};

printf(“排序在此以前n”);
printfArr(ArrayStr,4);

sortArrayStr(ArrayStr, 4);

printf(“排序之后n”);
printfArr(ArrayStr,4);

system(“pause”);
}

8.二级指针第三种内部存款和储蓄器模型(二维数组):

在栈中分配(二维数组型)内部存储器

#include “stdio.h”
#include “stdlib.h”
#include “string.h”

int printfArr22(char **ArrayStr, int iNum)
{
int i = 0;
for (i=0; i {
printf(“%s n”, ArrayStr[i]);
}
return 0;
}

//int array[10]===>int *array===>
// int printfArr22(char array[10], int iNum);
int printfArr23(char myArray[10][30], int iNum)
{
int i = 0;
for (i=0; i {
printf(“%s n”, myArray[i]);
}
return 0;
}

// int printfArr22(char array[10], int iNum);
int sortArr23(char myArray[10][30], int iNum)
{
int i = 0, j = 0;
char buf[30]; //buf数组名代表数组首成分之处
//排序
for (i=0; i<4; i++)
{
for (j=i+1; j<4; j++)
{
if (strcmp(myArray[i], myArray[j]) > 0)
{
strcpy(buf, myArray[i]);
strcpy(myArray[i],myArray[j]);
strcpy(myArray[j], buf);
}
}
}
}

void main()
{
int i = 0;
char myArray[10][30] = {“ccccc”, “aaaa”, “bbbb”,”11111″};

//打字与印刷第两种内部存款和储蓄器模型
for (i=0; i<4; i++)
{
printf(“%s n”, myArray[i]);
}

printf(“第三种内存模型,排序在此之前n”);
printfArr23(myArray, 4);
//printfArr23(myArray[10][30], 4);

sortArr23(myArray, 4);

printf(“第三种内部存款和储蓄器模型,排序之后n”);
printfArr23(myArray, 4);
system(“pause”);
}

9.二级指针第三种内部存款和储蓄器模型(手工业二维内部存款和储蓄器、二级指针):

在栈中的指针ArrayStr指向堆中分红的(指针数组型)内存

#include “stdio.h”
#include “stdlib.h”
#include “string.h”

int printfArr33(char **ArrayStr, int iNum)
{
int i = 0;
for (i=0; i {
printf(“%s n”, ArrayStr[i]);
}
return 0;
}

int printfArr2_23(char myArray[10][100], int iNum)
{
int i = 0;
for (i=0; i {
printf(“%s n”, myArray[i]);
}
return 0;

}

int sortArrayStr03(char **ArrayStr, int iNum)
{
int i = 0, j = 0;
char *tmp = NULL;
//排序
for (i=0; i {
for (j=i+1; j {
if (strcmp(ArrayStr[i],ArrayStr[j]) < 0)
{
tmp = ArrayStr[i];
ArrayStr[i] = ArrayStr[j];
ArrayStr[j] = tmp;
}
}
}
return 0;
}

void main()
{
int i = 0, j = 0;
char buf[100];
char **myarray = (char **)malloc(10*sizeof(char*)); //int
array[10]
if (myarray == NULL)
{
return;
}
for (i=0; i<10; i++)
{
myarray[i] = (char *)malloc(100*sizeof(char)); //char buf[100];
if (myarray[i] == NULL)
{
printf(“ddddden”);
return;
}
sprintf(myarray[i],”%d%d%d “, i, i, i);
}

//第三种内部存款和储蓄器模型打印
printf(“排序以前n”);
printfArr33(myarray, 10);
//printfArr2_23(myarray, 10卡塔尔; //第二种打字与印刷不适合 err

sortArrayStr03(myarray, 10);

//第二种内部存款和储蓄器模型打字与印刷
printf(“排序之后n”);
printfArr33(myarray, 10);

for (i=0; i<10; i++)
{
free(myarray[i] );
}
if (myarray != NULL)
{
free(myarray);
}

system(“pause”);
}

10.黄金年代维数组的本色(常量指针)

#include “stdio.h”
#include “stdlib.h”
#include “string.h”

void main()
{
int a;
int *p = NULL;
int i = 0;

//笔者证明了一个数组类型 (固定大小内部存款和储蓄器块的外号)
typedef int(MyArr5)[5];
//定义三个针对数组类型的指针变量
MyArr5 *pArray;// &a;
{
int j = 0;
int *pI = &j;
}
{
//int buf[10][30]
//a1代表数组首成分之处(不是大器晚成体数组的地址),请问a1 指针变量
//1变量–>2指针变量–》 3常量指针变量 (常量指针State of Qatar
//结论:无法被随意的修正指针变量的值(不能忽视的退换指针的对准)
//为啥它是三个const

//4在定义a1[5]的时候,编写翻译器分配内部存储器,为了能如愿的回笼内部存款和储蓄器,为了不常机让编写翻译器获得原始内部存储器首地址。
//编译器就把a1做成const量。
//无法深深的知道c指针各类现象,是发生bug的起点

int a1[5] = {1,3,4,55, 6};
//char *p = &a1;
//a1 = 0x11;

//给数组指针赋值 要求。。。&a1
MyArr5 *pArray = &a1; //4个字节
//用数组指针去遍历数组
for (i=0; i<5; i++)
{
//a1[i] = i;
// = i;
printf(“%d “, (*pArray)[i]);
}
}

{
//直接定义一个 数组指针类型 用那么些类型定义指针变量
//笔者注解了三个数组类型 (固定大小内部存款和储蓄器块的外号)
typedef int(MyArr5_1)[5];
//定义一个针对数组类型的指针变量
//声美素佳儿(FrisoState of Qatar个 数组指针类型
typedef int (*PMyArr5)[5];
PMyArr5 myP = NULL;

int b[5] = {1,3,4,55, 6};

myP = &b;

for (i=0; i<5; i++)
{
//a1[i] = i;
// = i;
printf(“%d “, (*myP)[i]);
}
}

{
int c[5] = {1,3,4,55, 6};
//定义二个针对性数组的指针变量
int (*myparra)[5] = &c;
for (i=0; i<5; i++)
{
printf(“%d “, (*myparra)[i]);
}
}
system(“pause”);
}

11.多(2)维数组的实质(数组指针)

#include “stdlib.h”
#include “string.h”
#include “stdio.h”

//注明二维数组的贮存,是线性的
void printArray(char aa[][5]);
void printArray2(int *p);

void main()
{
int a[3][5];
int c[5]; //&c + 1;
int b[10]; //b代表数组首成分的地点 &b代表这么些数组的地址 &b+1也正是指针后移4*10个单位
//指针步长===》铁的规律1

//a表示怎么样什么那?a是叁个数组指针 指向低维数组的指针
//a +1;
printf(“a:%d, a+1:%d n”, a, a+1); //4*5

{
int i=0, j = 0, tmp = 0;
for (i=0; i<3; i++)
{
for (j=0; j<5; j++)
{
a[i][j] = ++tmp;
}
}

printf(“n”);
for (i=0; i<3; i++)
{
for (j=0; j<5; j++)
{
printf(“%d n”, a[i][j]);
}
}
}

//a的真面目是一个数组指针。。。。每一遍以往跳风流洒脱维的维数。。。。。。
{
int i = 0, j = 0;
//定义了二个数组指针 变量
int (*myArrayPoint)[5] ; //告诉编写翻译给本身开发多少个字节内部存款和储蓄器
myArrayPoint = a;
printf(“n”);
for (i=0; i<3; i++)
{
for (j=0; j<5; j++)
{
//myArrayPoint[i][j] = ++tmp;
printf(“%d n”, myArrayPoint[i][j]);
}
}
}

/*
char array[10][30];
(array+i卡塔尔国 //约等于 第i行的首地址 //二级指针

(*(array+i卡塔尔(قطر‎)//生龙活虎维数组的首地址

(*(array+iState of Qatar)+j //相当于第i行第j列的地址了把。。。。

*((*(array+i卡塔尔(قطر‎)+j卡塔尔(قطر‎//相当于第i行第j列的地址了把。。。。<====>array[i][j]
*/
system(“pause”);
}

12.指针数组实例

#include “stdio.h”
#include “string.h”
#include “stdlib.h”
#include
#include

//演示:指针数组的用法
//演示:找错误 注意return

//求关键字在表中的职位
//叁个入口 多个开口
int searcheKeyTable(const char* table[], const int size, const char*
key, int *pos)
{
int rv = 0;
int i = 0;
int inum = 0;
if (table==NULL || key==NULL || pos==NULL)
{
rv = -1;
printf(“func searcheKeyTable:%d”, rv);
return rv;
}
inum = (sizeof(table)/sizeof(*table));

for(i=0; i {
if( strcmp(key, table[i]) == 0 )
{
*pos = i;
//break;
return rv;
}
}

//未有找到再次回到-1
if (i == size)
{
*pos = -1;
}
return rv;
}

#define DIM(a) (sizeof(a)/sizeof(*a))

int main61()
{
int inum = 0;
int pos = 0;
int a[10];
int i = 0;
//指针数组
char* c_keyword[] = {
“while”,
“case”,
“static”,
“do”
};

searcheKeyTable( c_keyword, DIM(c_keyword),”do”, &pos);
//searcheKeyTable( c_keyword, inum,”do”, &pos);
printf(“pos:%dn”, pos);
//searcheKeyTable(NULL, DIM(c_keyword),”do”, &pos);
//printf(“pos:%dn”, pos);
searcheKeyTable( c_keyword, DIM(c_keyword), “static”, &pos);
printf(“pos:%dn”, pos);

system(“pause”);
return ;
}

//main函数是操作系统调用的函数
//在程序实施的时候能够向main函数传递参数

/*
argc 命令行参数
argv 命令行参数数组
env 函数变量数组

int main();
int main(int argc);
int main(int argc, char *argv[])
*/

int main111(int argc, char* argv[], char**env)
{
int i = 0;
//main02_1();

printf(“******************* Begin argv
*******************n”);
for(i=0; i {
printf(“%sn”, argv[i]);
}

// for(i=0; argv[i]!=NULL; i++)
// {
// printf(“%sn”, argv[i]);
// }
printf(“******************* End argv
*******************n”);

printf(“n”);
printf(“n”);
printf(“n”);

printf(“******************* Begin env
*******************n”);

for(i=0; env[i]!=NULL; i++)
{
printf(“%sn”, env[i]);
}

printf(“******************* End
env*******************n”);

getchar();
}

int main()
{
int inum = 0;
int pos = 0;
int a[10];
int i = 0;
//指针数组
char* c_keyword[] = {
“while”,
“case”,
“static”,
“do”,
‘’
};
// NULL 0 ‘’

for(i=0; c_keyword[i]!=NULL; i++)
{
printf(“%sn”, c_keyword[i]);
}
system(“pause”);
}

13.野指南针及其释放难点

#include “stdio.h”
#include “stdlib.h”
#include “string.h”

int myfree(char *p2)
{
if (p2 != NULL卡塔尔(قطر‎//判别是不是内部存款和储蓄器被操作系统占用
{
free(p2);//释放
p2 = NULL;//释放后最佳“拴在”NULL处
}
}

void main()
{
//申明指针变量的时候null
char *p = NULL;//不起先化会时有爆发野指针
p = (char *State of Qatarmalloc(100卡塔尔国;//分配堆内部存款和储蓄器
//此处施行职业
myfree(p卡塔尔;//业务试行完结释放内存
/*
if (p != NULL)
{
free(p);
p = NULL;
}
若重新释放内存也会发出野指针,招致程序崩溃
*/
system(“pause”);
}

/*
4、三个球从100米中度自由落下,每一趟名落孙山后反跳回原中度的十分之五,再落下。求它在第14遍曝腮龙门时,共通过了略飞米?第14遍反弹多高?*/
#include<iostream.h>
void main()
{
double h1=100,h2=100,sum=0.0;
int i;
for(i=1;i<=10;i++)
{

1 字符串地址的测验

sum+=h2;
h1=h1/2.0;
h2=h1*2;
}
cout<<“sum=”<<sum<<”  
“<<“h1=”<<h1<<endl;
}

1.1 问题

测量检验字符串常量和字符数组 类型的变量地址是否近似。

/*
5、猴子吃桃问题。猴子第一天摘下多少个黄桃,当即吃了大意上,还不舒服,又多吃了八个。第二天早上又将多余的黄肉桃吃掉了大要上,又多吃了三个。未来每一天下午都吃了后天剩余的四分之二零三个。到第10天深夜想再吃时,见只剩四个毛桃了。求第一天共摘了稍微寿星桃。*/
#include<iostream.h>
void main()
{
int number,i;
number=1;
for(i=10;i>1;i–)
number=(number+1)*2;
cout<<“number=”<<number<<endl;
}

1.2 步骤

落实此案例要求依照如下步骤进行。

步骤风度翩翩:字符串地址的测量试验

代码如下所示:

  1. #include
  2. #include
  3.  
  4. int main()
  5. {
  6. char *str = “This is a string.”;
  7. char array[100];
  8. strcpy(array, str);
  9.  
  10. printf(“字符串常量的地点:%pn”, str);
  11. printf(“字符数组之处:%pn”, array);
  12.  
  13. return 0;
  14. }

上述代码中,以下代码:

  1. char *str = “This is a string.”;

概念了二个字符型指针str,用于指向一个字符串常量。

上述代码中,以下代码:

  1. printf(“字符串常量之处:%pn”, str);
  2. printf(“字符数组的地址:%pn”, array);

运用printf函数分别出口字符串常量的地址和字符数组的地点。从输出结果可以知道,它们是不相通的。

8.++顺序中央银行使流格式输入、输出,大家能够如何是好?
答:在前后相继的始发包含头文件iostream.h
     cin输入,cout输出。
例如:

1.3 完整代码

本案例的总体代码如下所示:

  1. #include
  2. #include
  3.  
  4. int main()
  5. {
  6. char *str = “This is a string.”;
  7. char array[100];
  8. strcpy(array, str);
  9.  
  10. printf(“字符串常量的地点:%pn”, str);
  11. printf(“字符数组的地点:%pn”, array);
  12.  
  13. return 0;
  14. }

#include<iostream.h>
void main()
{
   int a;
   cout<<“请输入a的值:”;
   cin>>a;
   cout<<“a的值为:”<<a<<endl;
}

2 字符串的概念和使用

第4章 函数

2.1 问题

概念三个int类型的指针,指向贰个整型变量,然后分别使用&和*赢得地点或然数额。

/* 1、写风华正茂函数用“气泡法”对输入的11个字符按由小到大的顺序排列。*/
#include<iostream.h>
void main()
{
int i,j,temp,a[10];
cout<<“please input ten numbers:n”;
for(i=0;i<10;i++)
cin>>a[i];
for(i=0;i<10;i++卡塔尔(قطر‎ //每循环三遍分明数组中八个数的职位
for(j=i+1;j<10;j++卡塔尔(قطر‎ //每便循环相比较贰个数的大大小小
{
if(a[i]>a[j])
{
temp=a[j];
a[j]=a[i];
a[i]=temp;
}
}
cout<<“resort result=”;
for(i=0;i<10;i++)
cout<<a[i]<<” “;
}

2.2 步骤

完毕此案例供给依据如下步骤举行。

步骤大器晚成:字符串的概念和利用

代码如下所示:

  1. #include
  2.  
  3. int main()
  4. {
  5. char str[5] = {};
  6. scanf(“%4s”, str);
  7. printf(“%sn”, str);
  8.  
  9. return 0;
  10. }

上述代码中,以下代码:

  1. char str[5] = {};

概念了三个字符数组str,该数组有5个因素。

上述代码中,以下代码:

  1. scanf(“%4s”, str);

使用scanf函数输入多少个字符串。当中,%4s是限量输入的字符串中字符的个数无法当先4,不然将只输入前4个字符。钦命值为4是因为字符数组str的尺寸为5,多出去的一个须求仓库储存。

上述代码中,以下代码:

  1. printf(“%sn”, str);

应用函数printf输出字符串。字符数组所对应的格式调控符是%s。

/* 2、用递归方法求n阶勒让得多项式的值,递归公式为
         1 (n = 0)
Pn(x) =  x (n = 1)
         ((2n-1)*x*Pn-1(x)-(n-1)*Pn-2(x))/n (n > 1) */
#include<iostream.h>
double fun (double,double);
void main()
{
double n,x,sum;
cout<<“input n and x”<<endl;
cin>>n>>x;
sum=fun(n,x);
cout<<“P”<<n<<“(“<<x<<“)”<<“=”<<sum<<endl;
}
double fun(double n1,double x1)
{
if (n1==0)
return 1;
else if (n1==1)
return  x1;
else if (n1>1)
return ((2*n1-1)*x1*fun(n1-1,x1)-(n1-1)*fun(n1-2,x1))/n1;
}

2.3 完整代码

本案例的完好代码如下所示:

  1. #include
  2.  
  3. int main()
  4. {
  5. char str[5] = {};
  6. scanf(“%4s”, str);
  7. printf(“%sn”, str);
  8.  
  9. return 0;
  10. }

/*
3、编写风流倜傥函数,由实参传来一字符串,计算此字符串中字母、数字、空格、和其余字符的个数,并在主函数中输入字符串甚至出口上述结果。
*/
#include<iostream.h>
void judge(char a[]);
void main()
{
const int size=100;
char a[size];
cin.getline(a,size);
judge(a);
}
void judge(char a[100]State of Qatar//剖断字符类型
{
int letter=0,number=0,others=0,i=0;
while(a[i]!=’’)
{
if ((a[i]>=’a’&&a[i]<=’z’)||(a[i]>=’A’&&a[i]<=’z’State of QatarState of Qatarletter++;//总计字母个数
else if (a[i]>=’0′ && a[i]<=’9’卡塔尔(قطر‎ number++;//总括数字个数
else others++;//总计别的数个数
i++;
}
cout<<“letter=”<<letter<<” 
number=”<<number<<”  others=”<<others<<endl;
}

3 字符串函数的施用

/* 4、给出年、月、日,总计该日是该年的第几天。 */
#include<iostream.h>
int lead(int);
void main()
{
int ly,year,month,date,i,sum=0;
cout<<“input year、month、date: “;
cin>>year>>month>>date;
int a[12]={31,0,31,30,31,30,31,31,30,31,30,31};
ly=lead(year);
if (ly==1)
a[1]=29;//366天
else a[1]=28;//365天
for(i=0;i<month-1;i++卡塔尔(قطر‎ //当前月事情发生在此以前全体月天数累积和
sum+=a[i];
sum+=date; //加被骗前月天数
cout<<“你输入的日子是当场的第”<<sum<<“天”;
}
int lead(int yState of Qatar//决断闰年
{
if((y%4==0&&y%100!=0)||(y%400==0)) return 1;//是闰年
else return 0;//不是闰年
}

3.1 问题

选择指针达成字符串的函数strlen(卡塔尔、strcat(卡塔尔(قطر‎的功用,可以自定义多少个函数。

/*
5、写四个函数,分别求四个整数的最大左券数和最小公倍数,用主函数调用那三个函数,并出口结果,四个整数由键盘输入。
*/
#include<iostream.h>
int cdivisor(int,int);
int cmultiple(int,int,int);
void main()
{
int x,y,d,m;
cout<<“input two number: “;
cin>>x>>y;
d=cdivisor(x,y);
m=cmultiple(x,y,d);
cout<<“common divisor is “<<d<<endl<<“common
multiple is “<<m<<endl;
}
int cdivisor(int x1,int y1卡塔尔国//最大公约数
{
int r,temp;
if (x1<y1)
{
temp=x1;
x1=y1;
y1=temp;
}
while(x1%y1卡塔尔//当十分大数除以一点都不大数余数等于0时,非常小数为最大左券数
{
r=x1%y1;
x1=y1;
y1=r;
}
return y1;
}
int cmultiple(int x2,int y2,int d1卡塔尔//最小公倍数
{
return x2*y2/d1;//两数相乘结果除以它们的最大合同数为最小公倍数
}

3.2 步骤

福衢寿车此案例要求依据如下步骤进行。

步骤后生可畏:字符串函数的采用

代码如下所示:

  1. #include
  2.  
  3. int mystrlen(char *str)
  4. {
  5. int count = 0;
  6. while (*str)
  7. {
  8. count++;
  9. str++;
  10. }
  11.  
  12. return count;
  13. }
  14.  
  15. char* mystrcat(char *s, char *d)
  16. {
  17. char* old = s;
  18. while(*s)
  19. s++;
  20. while(*d)
  21. {
  22. *s = *d;
  23. s++;
  24. d++;
  25. }
  26.  
  27. return old;
  28. }
  29.  
  30. int main()
  31. {
  32. char str[100] = “This is “;
  33. printf(“str的尺寸为:%dn”, mystrlen(str));
  34.  
  35. char* str1 = “a string”;
  36. mystrcat(str, str1);
  37. printf(“连接后的字符串为:%sn”, str);
  38.  
  39. return 0;
  40. }

上述代码中,以下代码:

  1. int mystrlen(char *str)
  2. {
  3. int count = 0;
  4. while (*str)
  5. {
  6. count++;
  7. str++;
  8. }
  9.  
  10. return count;
  11. }

概念了叁个函数mystrlen,用于模拟库函数strlen的功效。该函数的参数为求长度的字符串。在该函数中,以下语句:

  1. int count = 0;

率先定义几个整型变量count,用于存款和储蓄字符串中字符的个数。在该函数中,以下语句:

  1. while (*str)
  2. {
  3. count++;
  4. str++;
  5. }

设置贰个巡回,各种总结字符串中字符的个数,当*str不为时,代表该字符串未有终止。在该函数中,以下语句:

  1. return count;

重临字符串的长短。

上述代码中,以下代码:

  1. char* mystrcat(char *s, char *d)
  2. {
  3. char* old = s;
  4. while(*s)
  5. s++;
  6. while(*d)
  7. {
  8. *s = *d;
  9. s++;
  10. d++;
  11. }
  12.  
  13. return old;
  14. }

概念了一个函数mystrcat,用于模拟库函数strcat的意义。该函数的七个参数为将字符串d连接到字符串s的末尾。在该函数中,以下语句:

  1. char* old = s;

第大器晚成保存被接二连三字符串的首地址,用于函数停止重回时作再次来到值用。在该函数中,以下语句:

  1. while(*s)
  2. s++;

设置多少个巡回找到被一连字符串的终结符,以便将另二个字符串连接到这一个职责。在该函数中,以下语句:

  1. while(*d)
  2. {
  3. *s = *d;
  4. s++;
  5. d++;
  6. }

设置贰个生生不息将字符串d的每三个字符拷贝到字符串s的终止字符起先的空间中,完毕连接效用。在该函数中,以下语句:

  1. return old;

回来字符串s的首字符地址。

只顾:由于上述循环中,指针s已经发生了改换,所以不能够直接重临。

上述代码中,以下代码:

  1. int main()
  2. {
  3. char str[100] = “This is “;
  4. printf(“str的长度为:%dn”, mystrlen(str));

首先,在主函数中定义一个字符数组,用于存储字符串”This is “。

下一场,调用自定义函数mystrlen求得字符数组的长短,并出口。

上述代码中,以下代码:

  1. char* str1 = “a string”;
  2. mystrcat(str, str1);
  3. printf(“连接后的字符串为:%sn”, str);

首先,在主函数中定义一个字符指针,用于指向字符串”a string”。

接下来,调用自定义函数mystrcat将字符指针指向的字符串拼接到字符数组str中,并出口。

最终,输出连接后的字符数组str。

/* 6、写意气风发函数,将五个字符串连接。 */
#include<iostream.h>
#include<string.h>
void main()
{
const int size=100;
char a[size],b[size];
cout<<“input two string:”<<endl;
cin.getline(a,size);
cin.getline(b,size);
strcat(a,b);
cout<<“a=”<<a<<endl;
}

3.3 完整代码

本案例的欧洲经济共同体代码如下所示:

  1. #include
  2.  
  3. int mystrlen(char *str)
  4. {
  5. int count = 0;
  6. while (*str)
  7. {
  8. count++;
  9. str++;
  10. }
  11.  
  12. return count;
  13. }
  14.  
  15. char* mystrcat(char *s, char *d)
  16. {
  17. char* old = s;
  18. while(*s)
  19. s++;
  20. while(*d)
  21. {
  22. *s = *d;
  23. s++;
  24. d++;
  25. }
  26.  
  27. return old;
  28. }
  29.  
  30. int main()
  31. {
  32. char str[100] = “This is “;
  33. printf(“str的长度为:%dn”, mystrlen(str));
  34.  
  35. char* str1 = “a string”;
  36. mystrcat(str, str1);
  37. printf(“连接后的字符串为:%sn”, str);
  38.  
  39. return 0;
  40. }

/* 7、写风华正茂函数,将三个字符串的元音字母复制到另四个字符串,然后输出。
*/
#include<iostream.h>
#include<string.h>
void scpy(char *,char *);
void main()
{
const int size=100;
char a[size]=”Hello world”;
char b[size]=”Net”;
cout<<“a= “<<a<<“b= “<<b<<endl;
scpy(a,b);
cout<<“a= “<<a<<endl;
}
void scpy(char *p,char *q)
{
while(*q!=’’)
{
if
(*q==’a’||*q==’A’||*q==’e’||*q==’E’||*q==’i’||*q==’I’||*q==’o’||*q==’O’||*q==’u’||*q==’U’)
*p++=*q;
q++;
}
}

4 字符串函数的接收(续1卡塔尔(قطر‎

/*
8、写黄金年代函数,输入贰个四位数字,供给输出那4个数字字符,但每多个数字间空生机勃勃空格。如输入一九八九,应输出“1
9 9 0”。 */
#include<iostream.h>
#include<string.h>
void outs(char a[]);
void main()
{
const int size=10;
char a[size];
cin.getline(a,size);
outs(a);
}
void outs(char a[10])
{
int i;
if(strlen(a)<=4)
{
for(i=0;i<4;i++)
cout<<a[i]<<” “;
}
else cout<<“input error.”<<endl;
}

4.1 问题

使用指针函数达成公文名和文件目录的拼凑。

第5章   数组

4.2 步骤

兑现此案例要求据守如下步骤进行。

手续一:字符串函数的施用(续1卡塔尔(قطر‎

代码如下所示:

  1. #include
  2.  
  3. char* filenamecat(char *path, char* name)
  4. {
  5. char* old = path;
  6. while(*path)
  7. path++;
  8. if (*(path – 1) != ‘/’)
  9. {
  10. *path = ‘/’;
  11. path++;
  12. }
  13. while(*name)
  14. {
  15. *path = *name;
  16. path++;
  17. name++;
  18. }
  19.  
  20. return path;
  21. }
  22.  
  23. int main()
  24. {
  25. char path[100] = “/home/tarena/”;
  26. char* filename = “字符串函数的使用.c”;
  27. filenamecat(path, filename);
  28. printf(“带路线的公文名称叫:%sn”, path);
  29.  
  30. return 0;
  31. }

上述代码中,上面代码行:

  1. char* filenamecat(char *path, char* name)
  2. {
  3. char* old = path;
  4. while(*path)
  5. path++;
  6. if (*(path – 1) != ‘/’)
  7. {
  8. *path = ‘/’;
  9. path++;
  10. }
  11. while(*name)
  12. {
  13. *path = *name;
  14. path++;
  15. name++;
  16. }
  17.  
  18. return old;
  19. }

概念了三个函数filenamecat,用于拼接文件路线和文书名的效能。该函数的多少个参数为将文件名字符串name连接到路线字符串path的末尾。在该函数中,以下语句:

  1. char* old = path;

第大器晚成保存路线字符串的首地址,用于函数截至重返时作再次来到值用。在该函数中,以下语句:

  1. while(*path)
  2. path++;

安装五个巡回找到路线字符串的扫尾符,以便将文件名字符串连接到那个岗位。在该函数中,以下语句:

  1. if (*(path – 1) != ‘/’)
  2. {
  3. *path = ‘/’;
  4. path++;
  5. }

判别路线字符串的最后叁个字符是不是是/,如果不是则第一在门路字符串的末尾增加字符/。在该函数中,以下语句:

  1. while(*name)
  2. {
  3. *path = *name;
  4. path++;
  5. name++;
  6. }

安装几个巡回将文件名字符串name的每三个字符拷贝到路线字符串path的竣事字符/前边的半空中中,完毕连接成效。在该函数中,以下语句:

  1. return old;

归来路径字符串path的首字符地址。

注意:由于上述循环中,指针path已经发生了更动,所以无法一向重临path。

上述代码中,上面代码行:

  1. int main()
  2. {
  3. char path[100] = “/home/tarena/”;
  4. char* filename = “字符串函数的使用.c”;

率先,定义一个数组path,用于保存路线名。

接下来,定义四个指针filename,用于指向文件名。

上述代码中,上面代码行:

  1. filenamecat(path, filename);

调用自定义函数filenamecat,将文件名filename连接到路线名path的前面。

上述代码中,上面代码行:

  1. printf(“带路径的公文名叫:%sn”, path);

采纳函数printf输出连接后的路子Gavin件名。

/*
1、将一个数组中的值按逆序重新存放,举个例子,原本逐生机勃勃为:a、b、c、d。供给改为:d、c、b、a。
*/
#include<iostream.h>
void back(char *);
void main()
{
char a[50]=”abcdefg”;
cout<<“a=”<<a<<endl;
back(a);
}
#include<iostream.h>
void back(char *p)
{
int i=0;
while(*p!=’’)
{
p++;//把指针定位到字符串末尾
i++;//总计字符个数
}
cout<<“a=”;
for(;i>0;i–State of Qatar//逆序输出
{
p–;
cout<<*p;
}
cout<<endl;
}

4.3 完整代码

本案例的完全代码如下所示:

  1. #include
  2.  
  3. char* filenamecat(char *path, char* name)
  4. {
  5. char* old = path;
  6. while(*path)
  7. path++;
  8. if (*(path – 1) != ‘/’)
  9. {
  10. *path = ‘/’;
  11. path++;
  12. }
  13. while(*name)
  14. {
  15. *path = *name;
  16. path++;
  17. name++;
  18. }
  19.  
  20. return path;
  21. }
  22.  
  23. int main()
  24. {
  25. char path[100] = “/home/tarena/”;
  26. char* filename = “字符串函数的使用.c”;
  27. filenamecat(path, filename);
  28. printf(“带路线的文书名叫:%sn”, path);
  29.  
  30. return 0;
  31. }

/*
2、打字与印刷出杨辉三角形(必要打字与印刷出前15行)。(杨辉三角最本色的特色是,它的两条斜边都以由数字1整合的,而别的的数则是十分它肩上的三个数之和。卡塔尔
*/
#include<iostream.h>
void tri(int a[][15]);
void main()
{
int i,j,a[15][15];
tri (a);
cout<<“a= “;
for(i=0;i<15;i++卡塔尔国//遍历整个数组
{
for(j=0;j<=i;j++)
{
cout<<a[i][j];
if(a[i][j]>=1&&a[i][j]<=9卡塔尔国//当输出个位数之后输出4个空格保持有层有次
cout<<”    “;
else if
(a[i][j]>=10&&a[i][j]<=99卡塔尔//当输出12位数之后输出3个空格保持有条有理
cout<<”   “;
else
if(a[i][j]>=100&&a[i][j]<=999State of Qatar//当输出百位数之后输出2个空格保持井井有理
  cout<<”  “;
  else cout<<” “;//当输出百位数之后输出1个空格保持整齐不乱
}
cout<<endl<<”   “;//每行输出结束后换行
}
}
void tri(int a[15][15])
{
int i,j;
for(i=0;i<15;i++)
for(j=0;j<=i;j++)
{
if(j==0||j==iState of Qatar//三角形第一列和对角线被赋值为1
a[i][j]=1;
else a[i][j]=a[i-1][j-1]+a[i-1][j];//算出任何的数组成分
}
}

5 字符串的基本操作

/* 3、编生龙活虎程序,将八个字符串连接起来,不要用strcat函数。 */
#include<iostream.h>
#include<string.h>
void scat(char *,char *);
void main()
{
const int size=100;
char a[size]=”Hello”;
char b[size]=”Bye”;
cout<<“a=”<<a<<”   b=”<<b<<endl;
scat(a,b);
cout<<“a=”<<a<<” after link a and b”<<endl;
}
void scat(char *p,char *q)
{
while(*p!=’’卡塔尔国//明显数组a的插入地方
{
p++;
}
while(*q!=’’)
{
*p=*q;
p++;
q++;
}
}

5.1 问题

测验差异档案的次序的指针的算术运算。

/*
4、打字与印刷“魔方阵”。所谓魔方阵是指那样的方阵,它的每风姿罗曼蒂克行、每一列和对角线之和均相等。举例:三阶魔方阵:
      8 1 6
      3 5 7
      4 9 2
供给打字与印刷由1到n2的自然数构成的富有魔方阵。 */
//方法大器晚成:输出N介魔方阵,但每介只输出风流倜傥种。
#include<iostream.h>
void square(int a[][10],int k,int n);
void main()
{
int n,i,j,k,a[10][10]={0};
cout<<“input an odd number:”<<endl;
cin>>n;
k=n/2;//明确第多个数列数
square(a,k,n);
for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
cout<<“t”<<a[i][j];
cout<<endl;
}
}
void square(int a[][10],int k,int n)
{
int i,j;
for(i=1,j=0;i<=n*n;i++,j–,k++卡塔尔(قطر‎//n为阶数,从1方始给数组赋值
{
if(j<0&&k>=n卡塔尔(قطر‎//当数组行列都越出范围时候,分明数组正确地方
{
j+=2;k-=1;
}
else if(j<0卡塔尔//当数组行越出范围时候,分明数组准确地方
j+=n;
else if(k>=n卡塔尔国//当数组列越出范围时候,分明数组精确地方
          k-=n;
  else if(a[j][k]!=0State of Qatar//当数组原来的地点置有数时候,明确数组地点
  {
j+=2;k-=1;
  }
a[j][k]=i;
}
}
//方法二:输出N介魔方阵全部魔方阵。
#include <string>
#include <iomanip>
#include <iostream>

5.2 步骤

福衢寿车此案例须要依照如下步骤进行。

手续风华正茂:字符串的基本操作

代码如下所示:

  1. #include
  2. #include
  3.  
  4. int main()
  5. {
  6. char str[100];
  7. strcpy(str, “tarena”);
  8. printf(“字符串为:%sn”, str);
  9.  
  10. if (strcmp(str, “tarena”))
  11. printf(“字符串str与tarena不同n”);
  12. else
  13. printf(“字符串str与tarena相同n”);
  14.  
  15. printf(“sizeof(str) = %ldn”, sizeof(str));
  16. printf(“strlen(str) = %lun”, strlen(str));
  17.  
  18. strcat(str, ” C++方向”);
  19. printf(“字符串拼接后为:%sn”, str);
  20.  
  21. printf(“字符串拆分的前意气风发部分为:%sn”, strtok(str, ” “));
  22. printf(“字符串拆分的后豆蔻梢头有的为:%sn”, strtok(NULL, ” “));
  23.  
  24. char* p = strstr(str, “re”);
  25. if (p)
  26. printf(“子串re在字符串tarena中的地点为:%ldn”, p – str);
  27. else
  28. printf(“子串re不在字符串tarena中n”);
  29.  
  30. strcpy(str, “a 10 13.5”);
  31. int i;
  32. double d;
  33. char c;
  34. sscanf(str, “%c%d%lfn”, &c, &i, &d);
  35. printf(“%c %d %lfn”, c, i, d);
  36. memset(str, 0, sizeof(str));
  37. sprintf(str, “%c %d %lfn”, c, i, d);
  38. printf(“%sn”, str);
  39.  
  40. return 0;
  41. }

上述代码中,以下代码:

  1. char str[100];
  2. strcpy(str, “tarena”);
  3. printf(“字符串为:%sn”, str);

利用strcpy函数,将字符串”tarena”赋值到字符数组str中。

上述代码中,以下代码:

  1. if (strcmp(str, “tarena”))
  2. printf(“字符串str与tarena不同n”);
  3. else
  4. printf(“字符串str与tarena相同n”);

选用函数strcmp,每一种相比字符串”tarena”与字符数组str中的对应字符。假如具有对应字符均雷同则重回0,不然再次来到非0值。

上述代码中,以下代码:

  1. printf(“sizeof(str) = %ldn”, sizeof(str));
  2. printf(“strlen(str) = %lun”, strlen(str));

利用函数printf分别打字与印刷sizeof(str)和strlen(str)的值。从运维结果能够看见是不平等的。sizeof(str)输出的是字符数组str中装有因素所占的字节数。strlen(str)输出的是字符数组str中保留的字符串长度。

上述代码中,以下代码:

  1. strcat(str, ” C++方向”);
  2. printf(“字符串拼接后为:%sn”, str);

应用函数strcat在字符串str的结尾二个字符的前边连接上字符串” C++方向”。

上述代码中,以下代码:

  1. printf(“字符串拆分的前大器晚成部分为:%sn”, strtok(str, ” “));
  2. printf(“字符串拆分的后后生可畏都部队分为:%sn”, strtok(NULL, ” “));

行使函数strtok将刚拼接好的字符串str重新拆分成”tarena”和” C++方向”。

上述代码中,以下代码:

  1. char* p = strstr(str, “re”);
  2. if (p)
  3. printf(“子串re在字符串tarena中的地点为:%ldn”, p – str);
  4. else
  5. printf(“子串re不在字符串tarena中n”);

第后生可畏,使用函数strstr在字符串str中查找子串”re”是不是存在,假如存在则重回子串”re”的首先个字符r在字符串str的中的地址。然后,使用函数printf输出字符r在字符串中的地点。要是海市蜃楼,则输出子串不在字符串中。

上述代码中,以下代码:

  1. strcpy(str, “a 10 13.5”);
  2. int i;
  3. double d;
  4. char c;
  5. sscanf(str, “%c%d%lfn”, &c, &i, &d);
  6. printf(“%c %d %lfn”, c, i, d);

动用函数sscanf将字符串”a 10
13.5″中的字符a,整数10,双精度浮点数13.5调换来字符变量c,整型变量i,双精度浮点型变量d中。

上述代码中,以下代码:

  1. memset(str, 0, sizeof(str));
  2. sprintf(str, “%c %d %lfn”, c, i, d);
  3. printf(“%sn”, str);

先是,将字符数组str中的全体因素清0。

然后,使用sprintf将字符变量c,整型变量i,双精度浮点型变量d中的值调换到字符串,存储到数组str中。

using namespace std;

5.3 完整代码

本案例的欧洲经济共同体代码如下所示:

  1. #include
  2. #include
  3.  
  4. int main()
  5. {
  6. char str[100];
  7. strcpy(str, “tarena”);
  8. printf(“字符串为:%sn”, str);
  9.  
  10. if (strcmp(str, “tarena”))
  11. printf(“字符串str与tarena不同n”);
  12. else
  13. printf(“字符串str与tarena相同n”);
  14.  
  15. printf(“sizeof(str) = %ldn”, sizeof(str));
  16. printf(“strlen(str) = %lun”, strlen(str));
  17.  
  18. strcat(str, ” C++方向”);
  19. printf(“字符串拼接后为:%sn”, str);
  20.  
  21. printf(“字符串拆分的前豆蔻梢头部分为:%sn”, strtok(str, ” “));
  22. printf(“字符串拆分的后豆蔻梢头有个别为:%sn”, strtok(NULL, ” “));
  23.  
  24. char* p = strstr(str, “re”);
  25. if (p)
  26. printf(“子串re在字符串tarena中的地点为:%ldn”, p – str);
  27. else
  28. printf(“子串re不在字符串tarena中n”);
  29.  
  30. strcpy(str, “a 10 13.5”);
  31. int i;
  32. double d;
  33. char c;
  34. sscanf(str, “%c%d%lfn”, &c, &i, &d);
  35. printf(“%c %d %lfn”, c, i, d);
  36. memset(str, 0, sizeof(str));
  37. sprintf(str, “%c %d %lfn”, c, i, d);
  38. printf(“%sn”, str);
  39.  
  40. return 0;
  41. }

void printA(int **p,int n卡塔尔(قطر‎//输出这些n阶魔方阵
{
cout<<endl<<“上边是一个”<<n<<“阶魔方阵:”<<endl;

6 字符串数组和命令行参数的行使

int i,j;

6.1 问题

概念三国五虎司令员名单的数组,然后输入人名,推断是还是不是是五虎少将。

for(i = 0;i < n;i++)
{
for(j = 0;j < n;j++)
{
cout<<setw(4)<<p[i][j];
}

6.2 步骤

落实此案例须求依据如下步骤实行。

手续风流洒脱:定义五虎中校名单

应用字符指针数组作为名单。

代码如下:

  1. #include
  2.  
  3. int main(int argc, const char * argv[])
  4. {
  5. char *tiger[5] = {“GuanYu”, “ZhangFei”, “ZhaoYun”, “MaChao”,
    “HuangZhong”};
  6.  
  7. return 0;
  8. }

手续二:输入四个名字

概念三个字符数组,用于存储从调整台输入的名字。

代码如下:

  1. #include
  2.  
  3. int main(int argc, const char * argv[])
  4. {
  5. char *tiger[5] = {“GuanYu”, “ZhangFei”, “ZhaoYun”, “MaChao”,
    “HuangZhong”};
  6.  
  7. char name[20];
  8. printf(“请输入三个名字:”卡塔尔(قطر‎;
  9. scanf(“%s”, name);
  10.  
  11. return 0;
  12. }

步骤三:遍历数组

遍历数组,每个将数组成分与输入的名字相比,查找是或不是为五虎中校之豆蔻年华。

  1. #include
  2. #include
  3.  
  4. int main(int argc, const char * argv[])
  5. {
  6. char *tiger[5] = {“GuanYu”, “ZhangFei”, “ZhaoYun”, “MaChao”,
    “HuangZhong”};
  7.  
  8. char name[20];
  9. printf(“请输入四个名字:”State of Qatar;
  10. scanf(“%s”, name);
  11.  
  12. int i;
  13. for (i = 0; i < 5; i++)
  14. if (strcmp(name, tiger[i]) == 0)
  15. {
  16. printf(“%s是五虎中将之豆蔻梢头。n”, name);
  17. break;
  18. }
  19.  
  20. if (i == 5)
  21. printf(“%s不是五虎上校之生龙活虎。n”, name);
  22.  
  23. return 0;
  24. }

留心:strcmp函数要求满含string.h这几个头函数。

cout<<endl;
}

6.3 完整代码

本案例的完整代码如下所示:

  1. #include
  2. #include
  3.  
  4. int main(int argc, const char * argv[])
  5. {
  6. char *tiger[5] = {“GuanYu”, “ZhangFei”, “ZhaoYun”, “MaChao”,
    “HuangZhong”};
  7.  
  8. char name[20];
  9. printf(“请输入三个名字:”卡塔尔国;
  10. scanf(“%s”, name);
  11.  
  12. int i;
  13. for (i = 0; i < 5; i++)
  14. if (strcmp(name, tiger[i]) == 0)
  15. {
  16. printf(“%s是五虎中校之黄金年代。n”, name);
  17. break;
  18. }
  19.  
  20. if (i == 5)
  21. printf(“%s不是五虎上将之生龙活虎。n”, name);
  22.  
  23. return 0;
  24. }

cout<<endl<<endl;
}
bool Judge(int **p,int nState of Qatar//判定是或不是为n阶魔方阵
{
int i,j,sum = 0,NowSum = 0;
bool YesOrNo = true;

1 #include指令的利用

for(j = 0;j < n;j++卡塔尔国//第意气风发行总和
{
sum += p[0][j];
}

1.1 问题

测试#include的用法,包涵gcc –I钦命目录。

for(i = 1;i < n;i++卡塔尔(قطر‎//判定每行总和是或不是等于
{
NowSum = 0;
for(j = 0;j < n;j++)
{
NowSum += p[i][j];
}

1.2 步骤

落成此案例供给遵循如下步骤实行。

步骤一:#include指令的应用

代码如下所示:

  1. #include
  2. #include “print.c”
  3.  
  4. int main()
  5. {
  6. print();
  7.  
  8. return 0;
  9. }

上述代码中,以下代码:

  1. #include “print.c”

使用#include 指令将文件print.c中的内容增添到本程序的文书中。

上述代码中,以下代码:

  1. int main()
  2. {
  3. print();
  4.  
  5. return 0;
  6. }

在主程序中调用print.c中的函数print。

print.c代码如下所示:

  1. void print()
  2. {
  3. printf(“调用在文书print.c中的print函数n”);
  4. }

上述代码中,以下代码:

  1. printf(“调用在文书print.c中的print函数n”);

采纳函数printf输出提示,该函数被调用了。

if(NowSum != sum)
{
YesOrNo = false;

1.3 完整代码

本案例的完好代码如下所示:

  1. #include
  2. #include “print.c”
  3.  
  4. int main()
  5. {
  6. print();
  7.  
  8. return 0;
  9. }

print.c代码如下所示:

  1. void print()
  2. {
  3. printf(“调用在文书print.c中的print函数n”);
  4. }

goto END;
}
}

2 宏变量的选用

for(i = 0;i < n;i++卡塔尔//每列是不是等于
{
NowSum = 0;
for(j = 0;j < n;j++)
{
NowSum += p[j][i];
}

2.1 问题

测量试验宏变量的为主用法

if(NowSum != sum)
{
YesOrNo = false;

2.2 步骤

落到实处此案例需求依据如下步骤进行。

步骤意气风发:宏变量的选用

代码如下所示:

  1. #include
  2.  
  3. #define SIZE 10
  4. #define BEGIN int main() {
  5. #define END return 0; }
  6. #define LOOP for (int i = 0; i < SIZE; i++)
  7.  
  8. BEGIN
  9. int array[SIZE];
  10. printf(“请输入十三个整数(空格分隔State of Qatar:”卡塔尔国;
  11. LOOP scanf(“%d”, &array[i]);
  12.  
  13. LOOP printf(“array[%d] = %dn”, i, array[i]);
  14. END

上述代码中,以下代码:

  1. #define SIZE 10

概念四个宏变量SIZE,用于定义数组成分的个数。

上述代码中,以下代码:

  1. #define BEGIN int main() {

概念三个宏变量BEGIN,用于替代前面包车型客车主函数定义。

上述代码中,以下代码:

  1. #define END return 0; }

概念三个宏变量END,用于代替前面包车型地铁主函数再次来到。

上述代码中,以下代码:

  1. #define LOOP for (int i = 0; i < SIZE; i++)

概念贰个宏变量LOOP,用于替代设置多个生生不息。

上述代码中,以下代码:

  1. BEGIN

在预编写翻译阶段,会被代表为以下语句:

  1. int main() {

上述代码中,以下代码:

  1. LOOP scanf(“%d”, &array[i]);

在预编写翻译阶段,会被替代为以下语句:

  1. for (int i = 0; i < SIZE; i++) scanf(“%d”, &array[i]);

上述代码中,以下代码:

  1. LOOP printf(“array[%d] = %dn”, i, array[i]);

在预编写翻译阶段,会被替代为以下语句:

  1. for (int i = 0; i < SIZE; i++) printf(“array[%d] = %dn”, i,
    array[i]);

上述代码中,以下代码:

  1. END

在预编写翻译阶段,会被取代他为以下语句:

  1. return 0; }

goto END;
}
}

2.3 完整代码

本案例的总体代码如下所示:

  1. #include
  2.  
  3. #define SIZE 10
  4. #define BEGIN int main() {
  5. #define END return 0; }
  6. #define LOOP for (int i = 0; i < SIZE; i++)
  7.  
  8. BEGIN
  9. int array[SIZE];
  10. printf(“请输入十二个整数(空格分隔卡塔尔国:”State of Qatar;
  11. LOOP scanf(“%d”, &array[i]);
  12.  
  13. LOOP printf(“array[%d] = %dn”, i, array[i]);
  14. END

NowSum = 0;
for(i = 0,j = 0;i < n,j < n;i++,j++卡塔尔国//主对角线是或不是等于
{
NowSum += p[i][j];
}
if(NowSum != sum)
{
YesOrNo = false;

3 宏函数的概念

goto END;
}

3.1 问题

写一个宏函数,用它来证实五个日子是不是合法。

NowSum = 0;
for(i = n-1,j = 0;i >= 0,j < n;i–,j++卡塔尔//次对角线是或不是等于
{
NowSum += p[i][j];
}
if(NowSum != sum)
{
YesOrNo = false;

3.2 步骤

福衢寿车此案例供给依照如下步骤进行。

手续豆蔻梢头:宏函数的定义

  1. #define IS_DATE_VALID(year, month, day)
  2. if ((year) > 2000 && (year) < 2020 && (month) > 0 &&
    (month) < 13 && (day) > 0 && (day) < 32)
  3. printf(“日期官方n”);
  4. else
  5. printf(“日期不合规n”);
  6.  
  7. int main()
  8. {
  9. IS_DATE_VALID(2015,3,15);
  10.  
  11. return 0;
  12. }

上述代码中,以下代码:

  1. #define IS_DATE_VALID(year, month, day)
  2. if ((year) > 2000 && (year) < 2020 && (month) > 0 &&
    (month) < 13 && (day) > 0 && (day) < 32)
  3. printf(“日期官方n”);
  4. else
  5. printf(“日期违规n”);

概念了一个宏函数IS_DATE_VALID,用于测量检验叁个日期是或不是合法。上述代码中,
代表换行,当宏函数中的字符串相比长时,能够用它来作为换行符,不能够用回车,因为回车代表宏函数定义甘休。

上述代码中,以下代码:

  1. IS_DATE_VALID(2015,3,15);

在预编写翻译阶段,会被取而代之为以下语句:

  1. if ((year) > 2000 && (year) < 2020 && (month) > 0 &&
    (month) < 13 && (day) > 0 && (day) < 32)
  2. printf(“日期官方n”);
  3. else
  4. printf(“日期不合规n”);

goto END;
}

3.3 完整代码

本案例的完全代码如下所示:

  1. #define IS_DATE_VALID(year, month, day)
  2. if ((year) > 2000 && (year) < 2020 && (month) > 0 &&
    (month) < 13 && (day) > 0 && (day) < 32)
  3. printf(“日期官方n”);
  4. else
  5. printf(“日期非法n”);
  6.  
  7. int main()
  8. {
  9. IS_DATE_VALID(2015,3,15);
  10.  
  11. return 0;
  12. }

END:
return YesOrNo;
}
void combination(int **p,int n,int *a)//求m =
n*n个数(1,2,3…..m卡塔尔(قطر‎的全排列
{
int m = n*n;
static int Num = 0;
int *b_val = new int[m];
int c = 0,k,i,j;

4 条件编译的运用

b_val[c] = -1;//朝气蓬勃维数组首地址的值赋-1 c[0]-1
while(b_val[0] < m) //-1
{
if(++b_val[c] < m卡塔尔(قطر‎//分别从0开头增加每一个成分值,并节制不高于最大阶数
                 //b[0]0 [1]0 [1]1 [2]0 [2]1
[2]2…[6]6…[7]0…[7]7 [8]0…[8]8 推断魔方 [8]9
012345678
                      //                                              
[7]8 [8]0…[8]7 判别魔方 [8]8 [8]9 012345687
     //                                 [6]7…[7]0…[7]6       
[8]8 012345768
                                           //         012345786
     //                                                               
012345867 …
           //      876543210
{  
for(k = 0;k < c;k++State of Qatar//是不是与前段时间数字再一次,如有重复成分跳出,不然使K下标等于C下标                                 
if(b_val[k] ==
b_val[c])                                                    
break;
   
if(k ==
c卡塔尔//若无重新成分,就能够规定当前成分值,并接二连三排列下一个下标的数组成分
{
if(c+1 < mState of Qatar //1 2 3…7 8  
倘若不满意条件,则生成了后生可畏组排列格局,不然继续排列下多少个要素
           //          8
{   
++c; //1 2 3…7 8
//          8
b_val[c] = -1;
//   continue;
}
else  //生成了大器晚成组排列情势
{
k = -1;
for(i = 0;i < n;i++)
{
for(j = 0;j < n;j++)
{
p[i][j] = a[b_val[++k]];//a[0]-a[8]
}
}

4.1 问题

写四个头文件,使用准则编译完成防止再一次include。

//推断是或不是为n阶魔方阵
if(Judge(p,n))
{
printA(p,n);
}
}
}
}
else
{
c–;
}
}

4.2 步骤

福寿无疆此案例供给遵照如下步骤实行。

手续生龙活虎:条件编译的使用

main.c代码如下所示:

  1. #include
  2. #include “print.h”
  3.  
  4. int main()
  5. {
  6. print();
  7.  
  8. return 0;
  9. }

上述代码中,以下代码:

  1. #include “print.h”

使用#include 指令将文件print.h中的内容增多到本程序的文件中。

print.h文件,代码如下所示:

  1. #ifndef print_h
  2. #define print_h
  3.  
  4. void print();
  5.  
  6. #endif

上述代码中,以下代码:

  1. #ifndef print_h

采纳准绳编写翻译指令判定宏名print_h是或不是已经定义,如果未有定义继续推行下边包车型客车讲话,不然直接跳到#endif后边的语句实行。

上述代码中,以下代码:

  1. #define print_h

若无定义宏名print_h,则试行此语句定义该宏名,那样下一遍再利用#ifndef决断宏名print_h是还是不是已经定义时,由于已经定义将跳过#endif之间的言语,幸免重复include。

print.c文件,代码如下所示:

  1. #include
  2. #include “print.h”
  3.  
  4. void print()
  5. {
  6. printf(“幸免重复include例题n”);
  7. }

上述代码中,以下代码:

  1. #include “print.h”

在main.c函数中已经有此语句,若无准绳编写翻译语句会数14次暗含print.h文件。

delete []b_val;
}
void evaluate(int **p,int n卡塔尔(قطر‎//给n阶方阵的要素赋值
{
int i;

4.3 完整代码

本案例的总体代码如下所示:

main.c代码如下所示:

  1. #include
  2. #include “print.h”
  3.  
  4. int main()
  5. {
  6. print();
  7.  
  8. return 0;
  9. }

print.h文件,代码如下所示:

  1. #ifndef print_h
  2. #define print_h
  3.  
  4. void print();
  5.  
  6. #endif

print.c文件,代码如下所示:

  1. #include
  2. #include “print.h”
  3.  
  4. void print()
  5. {
  6. printf(“制止再一次include例题n”);
  7. }

int *AllNum = new int[3*3];
for(i = 1;i <= n*n;i++)
{
AllNum[i – 1] = i;
}

5 头文件的利用

combination(p,n,AllNum);

5.1 问题

写后生可畏组头文件,然后根据基准接受一个开展编写翻译。

渴求:实现防止重新导入而且测量试验static的作用。

delete []AllNum;
}
void main()
{
int i,n,**a;
string s;

5.2 步骤

落到实处此案例需求坚决守住如下步骤进行。

步骤一:short文件

short.h文件,代码如下所示:

  1. #ifndef short_h
  2. #define short_h
  3.  
  4. short add(short a, short b);
  5. short sub(short a, short b);
  6.  
  7. #endif

上述代码中,以下代码:

  1. #ifndef short_h
  2. #define short_h
  3.  
  4.  
  5. #endif

为严防重复include而预设的尺度编写翻译指令。

上述代码中,以下代码:

  1. short add(short a, short b);
  2. short sub(short a, short b);

宣称短整型的加法add、减法sub运算函数。

short.c文件,代码如下所示:

  1. #include “short.h”
  2.  
  3. short add(short a, short b)
  4. {
  5. return a + b;
  6. }
  7.  
  8. short sub(short a, short b)
  9. {
  10. return a – b;
  11. }

上述代码中,以下代码:

  1. short add(short a, short b)
  2. {
  3. return a + b;
  4. }

短整型的加法add函数的定义。

上述代码中,以下代码:

  1. short sub(short a, short b)
  2. {
  3. return a – b;
  4. }

短整型的减法sub函数的定义。

步骤二:standard文件

standard.h文件,代码如下所示:

  1. #ifndef int_h
  2. #define int_h
  3.  
  4. int add(int a, int b);
  5. int sub(int a, int b);
  6.  
  7. #endif

上述代码中,以下代码:

  1. int add(int a, int b);
  2. int sub(int a, int b);

声称整型的加法add、减法sub运算函数。

standard.c文件,代码如下所示:

  1. #include “standard.h”
  2.  
  3. int add(int a, int b)
  4. {
  5. return a + b;
  6. }
  7.  
  8. int sub(int a, int b)
  9. {
  10. return a – b;
  11. }

整型的加法add、减法sub运算函数的定义。

步骤三:long文件

long.h文件,代码如下所示:

  1. #ifndef long_h
  2. #define long_h
  3.  
  4. long add(long a, long b);
  5. long sub(long a, long b);
  6.  
  7. #endif

上述代码中,以下代码:

  1. long add(long a, long b);
  2. long sub(long a, long b);

宣示长整型的加法add、减法sub运算函数。

long.c文件,代码如下所示:

  1. #include “long.h”
  2.  
  3. long add(long a, long b)
  4. {
  5. return a + b;
  6. }
  7.  
  8. long sub(long a, long b)
  9. {
  10. return a – b;
  11. }

长整型的加法add、减法sub运算函数的概念。

步骤四:static文件

static.h文件,代码如下所示:

  1. #ifndef int_h
  2. #define int_h
  3.  
  4. static void print();
  5. void call();
  6.  
  7. #endif

上述代码中,以下代码:

  1. static void print();

声称了八个静态函数。该函数只好在本文件之中接受,在此外的.c文件中不可能运用。

上述代码中,以下代码:

  1. void call();

概念了一个习认为常函数。

static.c文件,代码如下所示:

  1. #include
  2. #include “static.h”
  3.  
  4. static int ex = 10;
  5.  
  6. void print()
  7. {
  8. printf(“那是静态函数,只可以在本文件中应用n”);
  9. }
  10.  
  11. void call()
  12. {
  13. print();
  14. printf(“静态变量:%dn”, ex);
  15. }

上述代码中,以下代码:

  1. static int ex = 10;

概念了八个静态变量ex,该变量只可以在本文件之中采取,在别的的.c文件中无法运用。

上述代码中,以下代码:

  1. void print()
  2. {
  3. printf(“那是静态函数,只好在本文件中使用n”);
  4. }

静态函数print的定义。

上述代码中,以下代码:

  1. void call()
  2. {
  3. print();
  4. printf(“静态变量:%dn”, ex);
  5. }

平时函数call的概念。由于静态函数print和静态变量ex,都与函数call在同二个文书中,所以以下语句:

  1. print();
  2. printf(“静态变量:%dn”, ex);

对静态函数print的调用和静态变量ex的应用是法定的。

步骤五:main文件

main.h文件,代码如下所示:

  1. #ifndef main_h
  2. #define main_h
  3.  
  4. #if defined(SHORT)
  5. #define FILE “short.h”
  6. #elif defined(STANDARD)
  7. #define FILE “standard.h”
  8. #elif defined(LONG)
  9. #define FILE “long.h”
  10. #endif
  11.  
  12. #include FILE
  13.  
  14. #endif

上述代码中,以下代码:

  1. #if defined(SHORT)
  2. #define FILE “short.h”

选取标准编译语句#if判别宏名SHORT是不是定义,就算定义则定义宏名FILE为”short.h”。

上述代码中,以下代码:

  1. #elif defined(STANDARD)
  2. #define FILE “standard.h”

选用原则编写翻译语句#elif决断宏名STANDALANDD是或不是定义,如果定义则定义宏名FILE为”standard.h”。

上述代码中,以下代码:

  1. #elif defined(LONG)
  2. #define FILE “long.h”

采用标准编写翻译语句#elif剖断宏名LONG是不是定义,就算定义则定义宏名FILE为”long.h”。

上述代码中,以下代码:

  1. #include FILE

蕴涵头文件FILE。

main.c文件,代码如下所示:

  1. #include
  2.  
  3. #define STANDARD
  4. #include “main.h”
  5. #include “static.h”
  6.  
  7. extern int ex;
  8.  
  9. int main()
  10. {
  11. printf(“5 + 3 = %dn”, add(5, 3));
  12. printf(“5 – 3 = %dn”, sub(5, 3));
  13.  
  14. //print();
  15. //printf(“静态变量:%dn”, ex);
  16. call();
  17.  
  18. return 0;
  19. }

上述代码中,以下代码:

  1. #define STANDARD
  2. #include “main.h”

概念宏名STANDA传祺D,那样在main.h少校实践#include “standard.h”。

上述代码中,以下代码:

  1. extern int ex;

声称三个外表变量ex。变量ex定义在static.c中,但出于变量ex被定义成静态变量,所以此语句毫无意义。

上述代码中,以下代码:

  1. printf(“5 + 3 = %dn”, add(5, 3));
  2. printf(“5 – 3 = %dn”, sub(5, 3));

调用的函数add和函数sub是被定义在standard.c中的函数add和函数sub。

上述代码中,以下代码:

  1. //print();

调用函数print是地下的。因为函数print是静态函数,只可以在static.c文件中被调用。

上述代码中,以下代码:

  1. //printf(“静态变量:%dn”, ex);

运用变量ex是违规的。因为变量ex是静态变量,只好在static.c文件中被运用。

上述代码中,以下代码:

  1. call();

调用call函数是官方的,因为函数call不是静态函数。

do
{
//输入n阶方阵的阶数n
cout<<“请输入n阶方阵的阶数n(退出程序按e或E键卡塔尔(قطر‎:”;
cin>>s;

5.3 完整代码

本案例的完整代码如下所示:

short.h文件,代码如下所示:

  1. #ifndef short_h
  2. #define short_h
  3.  
  4. short add(short a, short b);
  5. short sub(short a, short b);
  6.  
  7. #endif

short.c文件,代码如下所示:

  1. #include “short.h”
  2.  
  3. short add(short a, short b)
  4. {
  5. return a + b;
  6. }
  7.  
  8. short sub(short a, short b)
  9. {
  10. return a – b;
  11. }

standard.h文件,代码如下所示:

  1. #ifndef int_h
  2. #define int_h
  3.  
  4. int add(int a, int b);
  5. int sub(int a, int b);
  6.  
  7. #endif

standard.c文件,代码如下所示:

  1. #include “standard.h”
  2.  
  3. int add(int a, int b)
  4. {
  5. return a + b;
  6. }
  7.  
  8. int sub(int a, int b)
  9. {
  10. return a – b;
  11. }

long.h文件,代码如下所示:

  1. #ifndef long_h
  2. #define long_h
  3.  
  4. long add(long a, long b);
  5. long sub(long a, long b);
  6.  
  7. #endif

long.c文件,代码如下所示:

  1. #include “long.h”
  2.  
  3. long add(long a, long b)
  4. {
  5. return a + b;
  6. }
  7.  
  8. long sub(long a, long b)
  9. {
  10. return a – b;
  11. }

static.h文件,代码如下所示:

  1. #ifndef int_h
  2. #define int_h
  3.  
  4. static void print();
  5. void call();
  6.  
  7. #endif

static.c文件,代码如下所示:

  1. #include
  2. #include “static.h”
  3.  
  4. static int ex = 10;
  5.  
  6. void print()
  7. {
  8. printf(“那是静态函数,只可以在本文件中利用n”);
  9. }
  10.  
  11. void call()
  12. {
  13. print();
  14. printf(“静态变量:%dn”, ex);
  15. }

main.h文件,代码如下所示:

  1. #ifndef main_h
  2. #define main_h
  3.  
  4. #if defined(SHORT)
  5. #define FILE “short.h”
  6. #elif defined(STANDARD)
  7. #define FILE “standard.h”
  8. #elif defined(LONG)
  9. #define FILE “long.h”
  10. #endif
  11.  
  12. #include FILE
  13.  
  14. #endif

main.c文件,代码如下所示:

  1. #include
  2.  
  3. #define STANDARD
  4. #include “main.h”
  5. #include “static.h”
  6.  
  7. extern int ex;
  8.  
  9. int main()
  10. {
  11. printf(“5 + 3 = %dn”, add(5, 3));
  12. printf(“5 – 3 = %dn”, sub(5, 3));
  13.  
  14. //print();
  15. //printf(“静态变量:%dn”, ex);
  16. call();
  17.  
  18. return 0;
  19. }

if(!strcmp(s.c_str(),”e”) || !strcmp(s.c_str(),”E”))
{
break;
}
else if(s.find_first_not_of(“0123456789”) != string::npos)
{
cout<<“请输入有效的数字,无法含有非数字的字符。”<<endl;

6 makefile的使用

continue;
}
else
{
n = atoi(s.c_str());

6.1 问题

个别采纳静态起头化和动态早先化的艺术对数组实行赋值,并循环打字与印刷数组成分。

if(n < 1)
{
cout<<“请输入有效的数字,必需 >= 1。”<<endl;

6.2 步骤

福寿齐天此案例须要固守如下步骤实行。

步骤一:input文件

input.h,代码如下所示:

  1. #ifndef input_h
  2. #define input_h
  3.  
  4. void input();
  5.  
  6. #endif

上述代码中,以下代码:

  1. void input();

宣示了一个函数input。

input.c,代码如下所示:

  1. #include
  2.  
  3. extern int num;
  4.  
  5. void input()
  6. {
  7. printf(“请输入多个整数:”卡塔尔国;
  8. scanf(“%d”, &num);
  9. }

上述代码中,以下代码:

  1. extern int num;

宣称了三个表面变量num。该变量定义在main.c中。

上述代码中,以下代码:

  1. void input()
  2. {
  3. printf(“请输入叁个大背头:”卡塔尔(قطر‎;
  4. scanf(“%d”, &num);
  5. }

概念了函数input。

步骤二:output文件

output.h,代码如下所示:

  1. #ifndef output_h
  2. #define output_h
  3.  
  4. void output();
  5.  
  6. #endif

上述代码中,以下代码:

  1. void output();

宣称了贰个函数output。

output.c,代码如下所示:

  1. #include
  2.  
  3. extern int num;
  4.  
  5. void output()
  6. {
  7. printf(“%dn”, num);
  8. }

上述代码中,以下代码:

  1. extern int num;

宣示了一个外表变量num。该变量定义在main.c中。

上述代码中,以下代码:

  1. void output()
  2. {
  3. printf(“%dn”, num);
  4. }

概念了函数output。

步骤三:main文件

代码如下所示:

  1. #include
  2. #include “input.h”
  3. #include “output.h”
  4.  
  5. int num;
  6.  
  7. int main()
  8. {
  9. input();
  10. output();
  11.  
  12. return 0;
  13. }

上述代码中,以下代码:

  1. int num;

概念了叁个全局变量num。

上述代码中,以下代码:

  1. input();
  2. output();

调用函数input,对变量num进行输入。

调用函数output,对变量num举行输出。

步骤四:makefile文件

代码如下所示:

  1. main:main.o input.o output.o
  2. gcc main.c input.c output.c
  3.  
  4. main.o:main.c
  5. gcc main.c -c
  6. input.o:input.c
  7. gcc input.c -c
  8. output.o:output.c
  9. gcc output.c -c

能够应用makefile文件来三回性实行多条命令(批管理命令卡塔尔(قطر‎。makefile带给的平价就是“自动化编写翻译”,一旦写好,只须求二个make命令,整个工程全盘自行编写翻译,非常大的巩固了软件开拓的频率。

continue;
}

6.3 完整代码

本案例的意气风发体化代码如下所示:

input.h,代码如下所示:

  1. #ifndef input_h
  2. #define input_h
  3.  
  4. void input();
  5.  
  6. #endif

input.c,代码如下所示:

  1. #include
  2.  
  3. extern int num;
  4.  
  5. void input()
  6. {
  7. printf(“请输入叁个整数:”State of Qatar;
  8. scanf(“%d”, &num);
  9. }

output.h,代码如下所示:

  1. #ifndef output_h
  2. #define output_h
  3.  
  4. void output();
  5.  
  6. #endif

output.c,代码如下所示:

  1. #include
  2.  
  3. extern int num;
  4.  
  5. void output()
  6. {
  7. printf(“%dn”, num);
  8. }

main文件,代码如下所示:

  1. #include
  2. #include “input.h”
  3. #include “output.h”
  4.  
  5. int num;
  6.  
  7. int main()
  8. {
  9. input();
  10. output();
  11.  
  12. return 0;
  13. }

makefile文件,代码如下所示:

  1. main:main.o input.o output.o
  2. gcc main.c input.c output.c
  3.  
  4. main.o:main.c
  5. gcc main.c -c
  6. input.o:input.c
  7. gcc input.c -c
  8. output.o:output.c
  9. gcc output.c -c

Top

//分配内部存款和储蓄器
a = new int*[n];
for(i = 0; i < n; i++)
{
a[i] = new int[n];
}

 

cout<<“正在运算,请等待。。。。。。”<<endl;

1 构造的扬言和发轫化

//给n阶方阵的因素赋值
evaluate(a,n);

1.1 问题

概念测验构造体,并拓宽宣示变量和起先化。

cout<<“运算甘休!”<<endl;

1.2 步骤

达成此案例需求根据如下步骤进行。

手续意气风发:布局的宣示和初步化

代码如下所示:

  1. #include
  2.  
  3. struct student
  4. {
  5. int id;
  6. char name[10];
  7. }stu1;
  8.  
  9. int main()
  10. {
  11. stu1.id = 110;
  12. strcpy(stu1.name, “zhangsan”);
  13. printf(“学号:%d, 姓名:%s”, stu1.id, stu1.name);
  14.  
  15. struct student stu2 = {112, “lisi”};
  16. printf(“学号:%d, 姓名:%s”, stu2.id, stu2.name);
  17.  
  18. return 0;
  19. }

上述代码中,以下代码:

  1. struct student
  2. {
  3. int id;
  4. char name[10];
  5. }stu1;

概念学子组织体student。该布局体有三个成员,第二个成员是学号id,第二个分子是姓名name。在概念结构体student的同一时候定义了构造体变量stu1。

上述代码中,以下代码:

  1. stu1.id = 110;
  2. strcpy(stu1.name, “zhangsan”);
  3. printf(“学号:%d, 姓名:%s”, stu1.id, stu1.name);

首先,将布局体变量stu1的学号成员赋值为110。

接下来,将布局体变量stu1的人名成员赋值为”zhangsan”。

最后,输出构造体变量stu1。

上述代码中,以下代码:

  1. struct student stu2 = {112, “lisi”};
  2. printf(“学号:%d, 姓名:%s”, stu2.id, stu2.name);

先是,定义了另三个布局体变量stu2,并对其进展伊始化,将学号成员初始化为112,姓名成员初步化为”lisi”。

然后,输出构造体变量stu2。

for(i = 0; i < n; i++)
{
delete []a[i];
}
delete []a;
}
}while(1);

1.3 完整代码

本案例的全体代码如下所示:

  1. #include
  2.  
  3. struct student
  4. {
  5. int id;
  6. char name[10];
  7. }stu1;
  8.  
  9. int main()
  10. {
  11. stu1.id = 110;
  12. strcpy(stu1.name, “zhangsan”);
  13. printf(“学号:%d, 姓名:%s”, stu1.id, stu1.name);
  14.  
  15. struct student stu2 = {112, “lisi”};
  16. printf(“学号:%d, 姓名:%s”, stu2.id, stu2.name);
  17.  
  18. return 0;
  19. }

return;
}

2 布局的宣示和伊始化(续1卡塔尔

/* 5、求叁个3×3矩阵对角线成分之和。*/
#include<iostream.h>
int dia(int a[][3]);
void main()
{
int i,j,sum,a[3][3]={2,3,5,6,2,3,1,9,0};
cout<<“a= “;
for(i=0;i<3;i++)
{
for(j=0;j<3;j++)
cout<<a[i][j];
cout<<endl<<”   “;
}
sum=dia(a);
cout<<“nsum=”<<sum<<endl;
}
int dia(int a[3][3])
{
int i,j,sum=0;
for(i=0;i<3;i++卡塔尔(قطر‎//主对角线之和
for(j=i;j<=i;j++)
sum+=a[i][j];
for(j=0;j<3;j++卡塔尔国//另贰个对角线之和
for(i=2-j;i<=2-j;i++)
if(i!=j卡塔尔国//制止重复累计多个对焦向重合的成分
sum+=a[i][j];
return sum;//再次来到对角线员素之和
}

2.1 问题

概念构造点point,总结每一种点离(0,0卡塔尔(قطر‎的相距。

再定义构造rect(矩形State of Qatar,由多个点组成,计算矩形的面积。

/*
6、编写多少个主次,将字符数组s第22中学的全部字符拷贝到字符数组s1中。不用strcpy函数。拷贝时,‘’也要拷贝过去。
‘’前边的字符不拷贝。*/
#include<iostream.h>
void scopy(char a[],char b[]);
void main()
{
int i;
char a[10];
char b[10]=”Hello”;
scopy(a,b);
for(i=0;a[i]!=’’;i++)
cout<<a[i];
cout<<endl;
}
void scopy(char a[],char b[])
{
int i;
for(i=0;b[i]!=’’;i++)
{
a[i]=b[i];
}
a[i]=’’;
}

2.2 步骤

兑现此案例要求根据如下步骤进行。

手续意气风发:构造的宣示和早先化(续1卡塔尔

代码如下所示:

  1. #include
  2. #include
  3. #include
  4.  
  5. struct point
  6. {
  7. int x;
  8. int y;
  9. };
  10.  
  11. struct rect
  12. {
  13. struct point left_top;
  14. struct point right_bottom;
  15. };
  16.  
  17. int main()
  18. {
  19. struct point dot = {10, 20};
  20. int dis = sqrt(dot.x * dot.x + dot.y * dot.y);
  21. printf(“点(%d,%d)到原点(0,0)的间距是:%dn”, dot.x, dot.y,
    dis);
  22.  
  23. struct point a = {10, 10};
  24. struct point b = {50, 30};
  25. struct rect r = {a, b};
  26. int area = abs(r.left_top.x – r.right_bottom.x) *
    abs(r.left_top.y – r.right_bottom.y);
  27. printf(“矩形的面积是:%dn”, area);
  28.  
  29.  
  30. return 0;
  31. }

上述代码中,以下代码:

  1. struct point
  2. {
  3. int x;
  4. int y;
  5. };

概念三个布局体point,该布局体有两个分子,x轴坐标x,y轴坐标y。

上述代码中,以下代码:

  1. struct rect
  2. {
  3. struct point left_top;
  4. struct point right_bottom;
  5. };

概念一个布局体rect,该布局体有多个分子,左上角点坐标left_top,右下角点坐标right_bottom。

上述代码中,以下代码:

  1. struct point dot = {10, 20};

概念贰个结构体point的变量dot,并先导化为(10,20)。

上述代码中,以下代码:

  1. int dis = sqrt(dot.x * dot.x + dot.y * dot.y);

总括点dot到原点的相距。

上述代码中,以下代码:

  1. struct point a = {10, 10};
  2. struct point b = {50, 30};
  3. struct rect r = {a, b};

率先,定义两个结构体point的变量a和b,并早先化为(10,10)和(50,30)。

接下来,定义结构体rect的变量r,并用上述多个构造体point的变量a和b开始化。

上述代码中,以下代码:

  1. int area = abs(r.left_top.x – r.right_bottom.x) *
    abs(r.left_top.y – r.right_bottom.y);

算算矩形r面积。

/*
7、用筛选法求100之内的素数。(所谓素数正是除了1和它本身以外,不可能再被别的整数整除,这种数称作素数(也称质数卡塔尔。)*/
#include<iostream.h>
void main()
{
int i,j;
for(i=1;i<=100;i++)
{
for(j=2;j<i;j++卡塔尔国//判别素数
if(i%j!=0);
else break;//不是素数
if(i==jState of Qatar//相等为素数
cout<<” “<<i;
}
cout<<endl;
}

2.3 完整代码

本案例的完好代码如下所示:

  1. #include
  2. #include
  3. #include
  4.  
  5. struct point
  6. {
  7. int x;
  8. int y;
  9. };
  10.  
  11. struct rect
  12. {
  13. struct point left_top;
  14. struct point right_bottom;
  15. };
  16.  
  17. int main()
  18. {
  19. struct point dot = {10, 20};
  20. int dis = sqrt(dot.x * dot.x + dot.y * dot.y);
  21. printf(“点(%d,%d)到原点(0,0)的间距是:%dn”, dot.x, dot.y,
    dis);
  22.  
  23. struct point a = {10, 10};
  24. struct point b = {50, 30};
  25. struct rect r = {a, b};
  26. int area = abs(r.left_top.x – r.right_bottom.x) *
    abs(r.left_top.y – r.right_bottom.y);
  27. printf(“矩形的面积是:%dn”, area);
  28.  
  29.  
  30. return 0;
  31. }

/* 8、用选择法对拾叁个整数排序。*/
#include<iostream.h>
void csort(int a[10]);
void main()
{
int i;
int a[10]={6,4,2,7,9,0,1,6,3,0};
for(i=0;i<10;i++卡塔尔国//输出原数组数据顺序
cout<<a[i];
cout<<endl;
csort(a);
for(i=0;i<10;i++卡塔尔(قطر‎//输出排序后的风流洒脱朝气蓬勃
cout<<a[i];
cout<<endl;
}
void csort(int a[10])//排序
{
int i,j,k,temp=0;
for(i=1;i<10;i++)
{
k=i;
for(j=k+1;j<10;j++卡塔尔(قطر‎//找寻最小数的数组下标
if(a[k]>a[j])k=j;
if(k!=i)
{
temp=a[i];//把数放到准确地方
a[i]=a[k];
a[k]=temp;
}
}
}

3 布局的宣示和起首化(续2State of Qatar

第6章   指针

3.1 问题

概念贰个包涵月份的名字和当月天数的组织,用多个协会的数组保存一年中的全部月份和造化,在各种协会中保存四个月的名字和平运动气。

月份土耳其共和国语:January、February、March、April、May、June、July、奥古斯特、September、October、November、December。

/*
1、在主函数中输入12个字符串。用另生龙活虎函数对它们排序。然后在主函数输出那十个已排好序的字符串。(用指针完成)*/
#include<iostream.h>
void psort(int *p);
void main()
{
int i,a[10];
cout<<“please input ten numbers:n”;
for(i=0;i<10;i++)
cin>>a[i];
psort(a);
cout<<“resort result=”;
for(i=0;i<10;i++)
cout<<a[i]<<” “;
}
void psort(int *p)
{
int i,j,temp;
for(i=0;i<10;i++卡塔尔 //每循环二次显然数组中多个数的地点
for(j=i+1;j<10;j++卡塔尔 //每一趟循环相比二个数的尺寸
{
if(p[i]>p[j])
{
temp=p[j];
p[j]=p[i];
p[i]=temp;
}
}

3.2 步骤

福衢寿车此案例须要依照如下步骤进行。

手续风流倜傥:布局的扬言和开始化(续2State of Qatar

代码如下所示:

  1. #include
  2.  
  3. struct month
  4. {
  5. char name[10];
  6. int days;
  7. };
  8.  
  9. int main()
  10. {
  11. struct month m[12] = {
  12. {“January”, 31},
  13. {“February”, 28},
  14. {“March”, 31},
  15. {“April”, 30},
  16. {“May”, 31},
  17. {“June”, 30},
  18. {“July”, 31},
  19. {“August”, 31},
  20. {“September”, 30},
  21. {“October”, 31},
  22. {“November”, 30},
  23. {“December”, 31}};
  24.  
  25. for (int i = 0; i < 12; i++)
  26. printf(“%d月的名字是:%s,天数是:%dn”, i + 1, m[i].name,
    m[i].days);
  27.  
  28. return 0;
  29. }

上述代码中,以下代码:

  1. struct month
  2. {
  3. char name[10];
  4. int days;
  5. };

概念多个构造体month,该结构体有八个成员,前段日子的朝鲜语名字和上个月的运气。

上述代码中,以下代码:

  1. struct month m[12] = {
  2. {“January”, 31},
  3. {“February”, 28},
  4. {“March”, 31},
  5. {“April”, 30},
  6. {“May”, 31},
  7. {“June”, 30},
  8. {“July”, 31},
  9. {“August”, 31},
  10. {“September”, 30},
  11. {“October”, 31},
  12. {“November”, 30},
  13. {“December”, 31}};

概念了三个布局体month的数组m,该数组有十一个成分,每一种成分代表一年中的三个月。定义数组m之后,对其张开了初阶化。

潜心:伊始化时,每种数组元素的值用{}括起来。

}

3.3 完整代码

本案例的总体代码如下所示:

  1. #include
  2.  
  3. struct month
  4. {
  5. char name[10];
  6. int days;
  7. };
  8.  
  9. int main()
  10. {
  11. struct month m[12] = {
  12. {“January”, 31},
  13. {“February”, 28},
  14. {“March”, 31},
  15. {“April”, 30},
  16. {“May”, 31},
  17. {“June”, 30},
  18. {“July”, 31},
  19. {“August”, 31},
  20. {“September”, 30},
  21. {“October”, 31},
  22. {“November”, 30},
  23. {“December”, 31}};
  24.  
  25. for (int i = 0; i < 12; i++)
  26. printf(“%d月的名字是:%s,天数是:%dn”, i + 1, m[i].name,
    m[i].days);
  27.  
  28. return 0;
  29. }

/* 2、输入一个字符串,内有数字和非数字字符,如A123x456
1233?8997jhlkll
将当中再三再四的数字作为一个大背头,依次寄放到风姿罗曼蒂克数组a中,总括共有多少个整数,并出口那几个数。*/
#include<iostream.h>
#include<string.h>
#include <windows.h>
int charge(int *,char *);
void main()
{
int a[50],i,numb;
char b[50];
cout<<“please input a character string:”<<endl;
cin.getline(b,50);
system(“cls”);
cout<<“your character string is “;
cout.write(b,strlen(b))<<endl;
numb=charge(a,b);
for(i=0;i<numb;i++)
cout<<” a[“<<i<<“]=”<<a[i];
cout<<endl<<“total numbers=”<<numb<<endl;
}
int charge(int *q,char *p)//*q指向新数组,*p指向初阶数组
{
int numb=0;
for(;*p!=’’;p++State of Qatar//判定各类字符
{
if(*p>=’0’&&*p<=’9′)
{
*q=(*pState of Qatar-‘0’;//将字符型整数调换成整型整数赋值给新数组
p++;
while(*p>=’0’&&*p<=’9’State of Qatar//决断是或不是有连接字符型整数
{
*q=(*q)*10+((*pState of Qatar-‘0’卡塔尔;//将接连字符型整数调换到七个整型整数赋值给新数组
p++;
}
q++;
numb++;//总括整数的个数
}
}
return numb;
}

4 构造做参数

/* 3、用指向指针的指针的章程对5个字符串排序并出口。*/
#include <iostream.h>
#include <string.h>
void sort(char **str);
void main()
{
int i;
char *string[5];
cout<<“输入5个字符串:”<<endl;
for(i=0;i<5;i++)
{
string[i] = new char[10];
cin.getline(*(string+i),50);
}
sort(string);
for(i=0;i<5;i++)
delete [] string[i];
}
void sort(char **str)
{
int i=0,j;
char *p=0;
for(i=0;i<4;i++)
{
for(j=i+1;j<5;j++)
{
if(strcmp(*(str+i),*(str+j))<0)
{
p=*(str+i);
*(str+i)=*(str+j);
*(str+j)=p;
}
}
}
cout<<“after sort the chars :”<<endl;
for(i=0;i<5;i++)
{
cout<<*(str+i)<<endl;
}
}

4.1 问题

相比结构做参数的三种办法,使用->操作成员。

/* 4、总结一字符串在另二个字符串中冒出的次数。*/
#include<iostream.h>
#include<string.h>
int change(char *,char *);
void main()
{
int sum;
char a[10]=”dog”;
char b[20]=”sdlkdogsddydodog”;
cout.write(a,10)<<endl;
cout.write(b,20)<<endl;
sum=change(a,b);
cout<<“sum=”<<sum<<endl;
}
int change(char *p,char *q)
{
    int sum=0,i=0;
while(*q!=’’)
{
while(*p==*q&&*p!=’’卡塔尔(قطر‎//相比是还是不是带有相当字符串
{
*p++;
*q++;
i++;
}
if(*p==’’)
{
sum+=1;//含有字符串个数
}
p=p-i;//第五个字符串重新定位
q=q-i;//第1个字符串重新定位
i=0;//重新累计移动次数
q++;
}
return sum;
}

4.2 步骤

得以完毕此案例需求服从如下步骤举行。

步骤生机勃勃:构造做参数

代码如下所示:

  1. #include
  2. #include
  3.  
  4. struct student
  5. {
  6. int id;
  7. char name[10];
  8. }stu;
  9.  
  10. void print1(struct student stu)
  11. {
  12. printf(“学号:%d, 姓名:%sn”, stu.id, stu.name);
  13. }
  14.  
  15. void print2(struct student *p)
  16. {
  17. printf(“学号:%d, 姓名:%sn”, p->id, p->name);
  18. }
  19.  
  20. int main()
  21. {
  22. stu.id = 110;
  23. strcpy(stu.name, “zhangsan”);
  24. print1(stu);
  25. print2(&stu);
  26.  
  27. return 0;
  28. }

上述代码中,以下代码:

  1. struct student
  2. {
  3. int id;
  4. char name[10];
  5. }stu;

概念学子组织体student。该布局体有八个成员,第二个分子是学号id,第三个分子是姓名name。在概念构造体student的同临时候定义了构造体变量stu。

上述代码中,以下代码:

  1. void print1(struct student stu)
  2. {
  3. printf(“学号:%d, 姓名:%sn”, stu.id, stu.name);
  4. }

概念了一个函数print1,用于打字与印刷布局体student的变量的值。该函数有二个参数,是布局体student的变量stu。那是值传递的法子。布局体student的变量stu将是实参的别本。

上述代码中,以下代码:

  1. void print2(struct student *p)
  2. {
  3. printf(“学号:%d, 姓名:%sn”, p->id, p->name);
  4. }

概念了叁个函数print2,用于打字与印刷布局体student的变量的值。该函数有一个参数,是协会体student的指针变量p。那是地方传递的法子。布局体student的指针变量p将指向实参。该函数中,p->id是用指针p指向的构造体student的变量的id成员。

上述代码中,以下代码:

  1. stu.id = 110;
  2. strcpy(stu.name, “zhangsan”);

先是,将协会体student的变量stu的id成员赋值为110。

然后,将协会体student的变量stu的name成员赋值为”zhangsan”。

上述代码中,以下代码:

  1. print1(stu);

调用值传递格局的print1函数,实参为布局体student的变量stu。

上述代码中,以下代码:

  1. print2(&stu);

调用地址传递格局的print2函数,实参为布局体student的变量stu的地址。

/*
5、有n个整数,使其面前各数顺序向后移m个职位,最后m个数形成最前面包车型客车m个数.n和m从键盘输入。*/
#include<iostream.h>
#include<string.h>
void charge(int a[],int,int);
void main()
{
int i,n,m,a[50];
cout<<“请输入n的值:”;
cin>>n;
cout<<“请输入移动位数:”;
cin>>m;
cout<<“请输入整数:”;
for(i=0;i<n;i++)
{
cin>>a[i];
}
cout<<“您输入的大背头为:”;
for(i=0;i<n;i++)
{
cout<<a[i]<<” “;
}
cout<<endl;
charge(a,n,m);
cout<<“移动后的整数为:”;
for(i=0;i<n;i++)
{
cout<<a[i]<<” “;
}
cout<<endl;
}
void charge(int a[],int n, int m卡塔尔//n为整数个数,向右移动m个地点
{
int i,j;
for(j=0;j<m;j++)//移动m个位置
{
for(i=n-1;i>=0;i–卡塔尔//移动三个岗位将要移动每贰个数组成分
{
a[i+1]=a[i];
}
a[0]=a[n];
}
}

4.3 完整代码

本案例的完好代码如下所示:

  1. #include
  2. #include
  3.  
  4. struct student
  5. {
  6. int id;
  7. char name[10];
  8. }stu;
  9.  
  10. void print1(struct student stu)
  11. {
  12. printf(“学号:%d, 姓名:%sn”, stu.id, stu.name);
  13. }
  14.  
  15. void print2(struct student *p)
  16. {
  17. printf(“学号:%d, 姓名:%sn”, p->id, p->name);
  18. }
  19.  
  20. int main()
  21. {
  22. stu.id = 110;
  23. strcpy(stu.name, “zhangsan”);
  24. print1(stu);
  25. print2(&stu);
  26.  
  27. return 0;
  28. }

/*
6、有n个人围成意气风发圈,顺序排号。从第4个人开头报数(从1到3报数),凡报到3的人脱过逝界,问最终留给的是原来第几号的那位。*/
#include<iostream.h>
void change(int a[],int n);
void main()
{
int i,a[50],n;
cout<<“输入人数:”;
cin>>n;
for(i=0;i<n;i++)
a[i]=i+1;
change(a,n);
}
void change(int a[],int n)
{
int qnumber=0,i=0,k=0;
while(n-qnumber>1State of Qatar//直到只剩余1人时
{
if(a[i]!=0)k++; //报数
if(k==3)
{
a[i]=0; //退出圈子的人
qnumber++; //退出的总人数
k=0; //重新开头报数
}
i++;
if(i==n卡塔尔国i=0; //当全体人都报过数之后再度每人再度报数
}
for(i=0;i<n;i++)
if(a[i]!=0)cout<<a[i]<<” “;
}

5 构造做重临值

/* 7、写风度翩翩函数,完毕八个字符串的比较。即本人写二个strcmp函数。*/
#include<iostream.h>
#include<string.h>
int change(char *,char *);
void main()
{
int result;
char a[10]=”dog”;
char b[20]=”sdlkdogsddydodog”;
cout.write(a,10)<<endl;
cout.write(b,20)<<endl;
result=change(a,b);
cout<<“result=”<<result<<endl;
}
int change(char *p,char *q)
{
    int sum=0,i=0,flag=0;
while(*p!=’’&&*q!=’’)
{
if(*p>*q)
{
flag=1;//第二个字符串大于第二个字符串再次回到1
break;
}
if(*p<*q)
{
flag=-1;//第二叁个字符串大于第五个字符串重回-1
break;
}
if((*p==*q)&&*(p+1)==’’&&*(q+1)!=’’)
{
flag=-1;//第二一个字符串大于第叁个字符串重临-1
break;
}
*p++;
*q++;
}
return flag;
}

5.1 问题

测量检验间接回到构造的难题,并贯彻用布局指针参数带出数据。

/* 8、将叁个5 x
5的矩阵中最大的要素放在主旨,七个角分别放三个细微的成分(顺序为从左到右,从上到下顺序依次从小到大存放),写朝气蓬勃函数完毕之。用main函数调用。*/
#include<iostream.h>
void psort(int a[]);
void main()
{
int i;
int
a[25]={5,3,52,6,2,1,8,0,23,56,7,21,23,4,57,62,15,31,45,6,43,78,12,53,41};
for(i=0;i<25;i++)
{
cout<<” “<<a[i];
}
cout<<endl;
psort(a);
}
void psort(int a[])
{
int i,j,k=0,temp,b[5][5];
for(i=0;i<25;i++卡塔尔(قطر‎ //每循环一回鲜明数组中一个数的职位
for(j=i+1;j<25;j++卡塔尔国 //每一回循环相比较二个数的大大小小
{
if(a[i]>a[j])
{
temp=a[j];
a[j]=a[i];
a[i]=temp;
}
}
for(i=0;i<5;i++)
for(j=0;j<5;j++)
{
b[i][j]=a[k++];
}
temp=b[4][4]; //分明5个岗位的数值
b[4][4]=b[2][2];
b[2][2]=temp;
temp=b[0][1];
b[0][1]=b[0][4];
b[0][4]=temp;
temp=b[0][2];
b[0][2]=b[4][0];
b[4][0]=temp;
temp=b[0][3];
b[0][3]=b[4][4];
b[4][4]=temp;
for(i=0;i<5;i++)
{
for(j=0;j<5;j++)
{
cout<<“t”<<b[i][j];
}
cout<<endl;
}
}

5.2 步骤

落到实处此案例供给依照如下步骤进行。

手续风流洒脱:布局做再次来到值

代码如下所示:

  1. #include
  2.  
  3. struct student
  4. {
  5. int id;
  6. char name[10];
  7. };
  8.  
  9. struct student input1()
  10. {
  11. struct student stu;
  12. printf(“输入学号:”卡塔尔国;
  13. scanf(“%d”, &stu.id);
  14. printf(“输入人名:”卡塔尔(قطر‎;
  15. scanf(“%s”, stu.name);
  16.  
  17. return stu;
  18. }
  19.  
  20. void input2(struct student *p)
  21. {
  22. printf(“输入学号:”卡塔尔国;
  23. scanf(“%d”, &p->id);
  24. printf(“输入姓名:”卡塔尔;
  25. scanf(“%s”, p->name);
  26. }
  27.  
  28. int main()
  29. {
  30. struct student stu;
  31. stu = input1();
  32. printf(“学号:%d, 姓名:%sn”, stu.id, stu.name);
  33.  
  34. input2(&stu);
  35. printf(“学号:%d, 姓名:%sn”, stu.id, stu.name);
  36.  
  37. return 0;
  38. }

上述代码中,以下代码:

  1. struct student
  2. {
  3. int id;
  4. char name[10];
  5. };

概念学子组织体student。该布局体有多少个成员,第三个成员是学号id,第四个分子是姓名name。

上述代码中,以下代码:

  1. struct student input1()
  2. {
  3. struct student stu;
  4. printf(“输入学号:”卡塔尔(قطر‎;
  5. scanf(“%d”, &stu.id);
  6. printf(“输入姓名:”卡塔尔国;
  7. scanf(“%s”, stu.name);
  8.  
  9. return stu;
  10. }

概念三个函数input1,用于输入。该函数中,以下语句:

  1. struct student stu;

概念了叁个局地协会体student的变量stu。该函数中,以下语句:

  1. printf(“输入学号:”卡塔尔国;
  2. scanf(“%d”, &stu.id);
  3. printf(“输入人名:”State of Qatar;
  4. scanf(“%s”, stu.name);

输入学号和人名。该函数中,以下语句:

  1. return stu;

回到结构体student的变量stu。

上述代码中,以下代码:

  1. void input2(struct student *p)
  2. {
  3. printf(“输入学号:”State of Qatar;
  4. scanf(“%d”, &p->id);
  5. printf(“输入人名:”卡塔尔;
  6. scanf(“%s”, p->name);
  7. }

概念二个函数input2,用于输入,该函数有三个参数,是指向布局体student的指针变量p。该函数中,以下语句:

  1. printf(“输入学号:”State of Qatar;
  2. scanf(“%d”, &p->id);
  3. printf(“输入姓名:”卡塔尔;
  4. scanf(“%s”, p->name);

将学号和人名输入到协会体student的指针变量p指向的实参。

上述代码中,以下代码:

  1. int main()
  2. {
  3. struct student stu;
  4. stu = input1();
  5. printf(“学号:%d, 姓名:%sn”, stu.id, stu.name);

在主函数中,定义构造体student的变量stu,用于收纳函数input1的重临值。

上述代码中,以下代码:

  1. input2(&stu);
  2. printf(“学号:%d, 姓名:%sn”, stu.id, stu.name);

在主函数中,将协会体student的变量stu的地点作为实参传入input2,以输入其值。

第7章 构造体与共用体

5.3 完整代码

本案例的完整代码如下所示:

  1. #include
  2.  
  3. struct student
  4. {
  5. int id;
  6. char name[10];
  7. };
  8.  
  9. struct student input1()
  10. {
  11. struct student stu;
  12. printf(“输入学号:”卡塔尔(قطر‎;
  13. scanf(“%d”, &stu.id);
  14. printf(“输入姓名:”卡塔尔(قطر‎;
  15. scanf(“%s”, stu.name);
  16.  
  17. return stu;
  18. }
  19.  
  20. void input2(struct student *p)
  21. {
  22. printf(“输入学号:”卡塔尔国;
  23. scanf(“%d”, &p->id);
  24. printf(“输入人名:”卡塔尔国;
  25. scanf(“%s”, p->name);
  26. }
  27.  
  28. int main()
  29. {
  30. struct student stu;
  31. stu = input1();
  32. printf(“学号:%d, 姓名:%sn”, stu.id, stu.name);
  33.  
  34. input2(&stu);
  35. printf(“学号:%d, 姓名:%sn”, stu.id, stu.name);
  36.  
  37. return 0;
  38. }

/*
1、用指针和构造体完成一双向链表,并贯彻其对应的增、删、遍历功效,并在实例中利用它。*/
#include <iostream.h>

6 构造的对齐和补齐

typedef struct node
{
int number;

6.1 问题

对齐是指由于内部存储器分配会将组织中的变量分配到内部存款和储蓄器的分界上,以造福访谈。每种成员放的岗位是从自己尺寸的翻番位发轫放。

补齐是指任何布局变量的长短要维持内部最长成员(当先4以4计卡塔尔(قطر‎的倍数。若是相当不足,则补齐。

struct node *next;
struct node *parent;
}Node,*LinkNode;

6.2 步骤

福寿年高此案例需求据守如下步骤举办。

步骤风流倜傥:布局的对齐和补齐

代码如下所示:

  1. #include
  2.  
  3. struct size
  4. {
  5. char c;
  6. int i;
  7. };
  8.  
  9. int main()
  10. {
  11. printf(“sizeof(size) = %ldn”, sizeof(struct size));
  12.  
  13. return 0;
  14. }

上述代码中,以下代码:

  1. struct size
  2. {
  3. char c;
  4. int i;
  5. };

概念二个布局体size,该构造体有多个成员,字符型变量c和整型变量i。

上述代码中,以下代码:

  1. printf(“sizeof(size) = %ldn”, sizeof(struct size));

输出构造体size所占的字节数。从出口结果可以看到是8个字节。为何不是5个字节呢?

案由是字符对齐的概念。当二个构造体被分配存储空间时,分配的不二法门是这么的:

首先,找到结构体中占字节数最多的积极分子,本案例中是整型变量i。

下一场,以该成员所占的字节数为单位,为布局体的各样成员分红存款和储蓄空间。在那案例中,为率先个成员字符型变量c分配4个字节,该成员用掉1个字节,剩下3个字节。字符型变量c所占的要命字节的号码设为0,剩下的3个字节编号挨个为1、2、3。

最后,为第贰个成员整型变量i分配存款和储蓄空间,由于剩下的3个字节的号子挨个为1、2、3,用这一个号码对整型变量i所占字节数4求余,结果都不为0,所以剩下的3个字节都跳过。而再分配4个字节给整型变量i。

之所以本案例的输出结果为8个字节,并非5个字节。因为有多少个字节未有用。

class LinkClass
{
public:
LinkNode first,current;//头指针,当前线指挥部针
void init(卡塔尔(قطر‎;//伊始化函数
LinkNode Insert(int data,LinkNode curState of Qatar;//插入函数
void Remove(LinkNode p卡塔尔(قطر‎;//删除函数
void Prior(LinkNode head卡塔尔(قطر‎;//遍历函数
};

6.3 完整代码

本案例的完好代码如下所示:

  1. #include
  2.  
  3. struct size
  4. {
  5. char c;
  6. int i;
  7. };
  8.  
  9. int main()
  10. {
  11. printf(“sizeof(size) = %ldn”, sizeof(struct size));
  12.  
  13. return 0;
  14. }

void LinkClass::init()
{
struct node *head=new struct node;
struct node *tail=new struct node;

7 联合的着力用法

head->parent=NULL;
head->next=tail;
tail->parent=head;
tail->next=NULL;
first=current=head;
}

7.1 问题

同步就是一块内部存款和储蓄器对应不一致的品类,并起了不相同的名字,在行使时根据名字切换类型,实际不是用类型调换。

LinkNode LinkClass::Insert(int data,LinkNode cur)
{
struct node *newNode=new struct node;
newNode->number = data;
newNode->next = cur->next;
cur->next = newNode;
newNode->parent = cur;
newNode->next->parent = newNode;
cur=newNode;
return cur;
}

7.2 步骤

贯彻此案例须求依据如下步骤进行。

步骤黄金年代:联合的主导用法

代码如下所示:

  1. #include
  2.  
  3. union data
  4. {
  5. int a;
  6. int b;
  7. int c;
  8. };
  9.  
  10. int main()
  11. {
  12. union data d;
  13. d.a = 10;
  14. printf(“%d %d %dn”, d.a, d.b, d.c);
  15.  
  16. d.b = 20;
  17. printf(“%d %d %dn”, d.a, d.b, d.c);
  18.  
  19. d.c = 30;
  20. printf(“%d %d %dn”, d.a, d.b, d.c);
  21.  
  22. return 0;
  23. }

上述代码中,以下代码:

  1. union data
  2. {
  3. int a;
  4. int b;
  5. int c;
  6. };

概念了叁个合营data,该联合中有五个成员,那四个分子共用4个字节。

上述代码中,以下代码:

  1. union data d;
  2. d.a = 10;
  3. printf(“%d %d %dn”, d.a, d.b, d.c);

第风流罗曼蒂克,定义二个合办data的变量d。

下一场,将同步data的变量d的首先个成员a赋值为10。

最终,使用printf输出联合data的八个成员的值。从出口结果能够看来,值都未有差距。并且,后四个成员未赋值。原因是一路data的四个分子共用4个字节。

上述代码中,以下代码:

  1. d.b = 20;
  2. printf(“%d %d %dn”, d.a, d.b, d.c);

将联袂data的变量d的第二个成员b赋值为20。从出口结果能够观望,联合data的八个成员的值都相似。原因是一齐data的七个分子共用4个字节。

上述代码中,以下代码:

  1. d.c = 30;
  2. printf(“%d %d %dn”, d.a, d.b, d.c);

将联合data的变量d的第多个成员c赋值为30。从出口结果能够见到,联合data的多个成员的值依旧都雷同。原因如故三只data的八个分子共用4个字节。

void LinkClass::Prior(LinkNode head)
{
LinkNode cur=head->next;
while(cur->next!=NULL)
{
cout<<cur->number<<” “;
cur=cur->next;
}
cout<<“”<<endl;
}

7.3 完整代码

本案例的全体代码如下所示:

  1. #include
  2.  
  3. union data
  4. {
  5. int a;
  6. int b;
  7. int c;
  8. };
  9.  
  10. int main()
  11. {
  12. union data d;
  13. d.a = 10;
  14. printf(“%d %d %dn”, d.a, d.b, d.c);
  15.  
  16. d.b = 20;
  17. printf(“%d %d %dn”, d.a, d.b, d.c);
  18.  
  19. d.c = 30;
  20. printf(“%d %d %dn”, d.a, d.b, d.c);
  21.  
  22. return 0;
  23. }

void LinkClass::Remove(LinkNode cur)
{
LinkNode temp=cur;
temp->parent->next=temp->next;
temp->next->parent=temp->parent;
delete(temp);
}

8 枚举的中央用法

void main()
{
LinkClass lc;
lc.init();
LinkNode cur=lc.current;
for(int i=0;i<=10;i++卡塔尔国//用循环来早先化构造体内的number
{
cur=lc.Insert(i,curState of Qatar;//调用插入函数
}
LinkNode head=lc.first;
cout<<“没调用删除函数的遍历:”<<endl;
lc.Prior(head卡塔尔国;//遍历函数
for(int j=0;j<=3;j++State of Qatar//删除成分6
{
cur=cur->parent;
}
lc.Remove(curState of Qatar;//实践删除函数
cout<<“调用删除函数后的遍历:”<<endl;
lc.Prior(head);
}

8.1 问题

枚举是贰个整型常量的列表,日常的话,值是有限个。各种值都以枚举常量(整型)。能够定义时钦命值,也足以八个枚举名表示同三个值。枚举常量可看成字面量。

/* 2、用指针和布局体达成栈及其方法,并在实例中使用它。*/
#include <stdlib.h>
#include <iostream.h>

8.2 步骤

落到实处此案例要求依据如下步骤实行。

手续生机勃勃:枚举的主导用法

代码如下所示:

  1. #include
  2.  
  3. enum WEEK
  4. {
  5. Monday = 1, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday,
  6. };
  7.  
  8. int main()
  9. {
  10. int day;
  11. printf(“请输入今天是星期几:”卡塔尔;
  12. scanf(“%d”, &day);
  13.  
  14. switch(day)
  15. {
  16. case Monday:
  17. printf(“星期一n”);
  18. break;
  19. case Tuesday:
  20. printf(“星期二n”);
  21. break;
  22. case Wednesday:
  23. printf(“星期三n”);
  24. break;
  25. case Thursday:
  26. printf(“星期四n”);
  27. break;
  28. case Friday:
  29. printf(“星期五n”);
  30. break;
  31. case Saturday:
  32. printf(“星期六n”);
  33. break;
  34. case Sunday:
  35. printf(“星期日n”);
  36. break;
  37. }
  38.  
  39. return 0;
  40. }

上述代码中,以下代码:

  1. enum WEEK
  2. {
  3. Monday = 1, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday,
  4. };

概念了多个枚举WEEK,是一个整型常量的列表,Monday是1,后边的值依次加1。

上述代码中,以下代码:

  1. int day;
  2. printf(“请输入今天是星期几:”卡塔尔国;
  3. scanf(“%d”, &day);

率先,定义叁个整型变量day,用于存款和储蓄星期几的整数。

然后,使用printf提醒输出输入星期几。

谈起底,使用scanf输入星期几到整型变量day中。

上述代码中,以下代码:

  1. switch(day)
  2. {
  3. case Monday:
  4. printf(“星期一n”);
  5. break;
  6. case Tuesday:
  7. printf(“星期二n”);
  8. break;
  9. case Wednesday:
  10. printf(“星期三n”);
  11. break;
  12. case Thursday:
  13. printf(“星期四n”);
  14. break;
  15. case Friday:
  16. printf(“星期五n”);
  17. break;
  18. case Saturday:
  19. printf(“星期六n”);
  20. break;
  21. case Sunday:
  22. printf(“星期日n”);
  23. break;
  24. }

行使switch构造将整形星期几转变到字符串的星期几。其中各种case前边为一个枚举值。

#define STACK_INIT_SIZE 100
#define STACKIN 10

8.3 完整代码

本案例的完好代码如下所示:

  1. #include
  2.  
  3. enum WEEK
  4. {
  5. Monday = 1, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday,
  6. };
  7.  
  8. int main()
  9. {
  10. int day;
  11. printf(“请输入几这两天是星期几:”卡塔尔(قطر‎;
  12. scanf(“%d”, &day);
  13.  
  14. switch(day)
  15. {
  16. case Monday:
  17. printf(“星期一n”);
  18. break;
  19. case Tuesday:
  20. printf(“星期二n”);
  21. break;
  22. case Wednesday:
  23. printf(“星期三n”);
  24. break;
  25. case Thursday:
  26. printf(“星期四n”);
  27. break;
  28. case Friday:
  29. printf(“星期五n”);
  30. break;
  31. case Saturday:
  32. printf(“星期六n”);
  33. break;
  34. case Sunday:
  35. printf(“星期日n”);
  36. break;
  37. }
  38.  
  39. return 0;
  40. }

预管理 布局体
项目支付中字符串模型创设 strstr的while dowhile模型 //int
cltClient_rev(void *handle, unsigned char *buf, int *buflen)
//不要相…

struct stack
{
int *top;
int *base;
int stacksize;
    int initstack(stack &s)
{
s.base=(int *)malloc(STACK_INIT_SIZE * sizeof(int));
if(!s.base) return 0;
s.top=s.base;
s.stacksize =STACK_INIT_SIZE;
return 1;

}
int gettop(stack s,int &e)
{
if(s.top ==s.base) return 0;
e=*(s.top-1);
return 1;
}
int push(stack &s,int e)
{
if(s.top -s.base>=s.stacksize)
{
s.base=(int *)realloc(s.base,(s.stacksize + STACKIN)*sizeof(int));
if(!s.base) return 0;
s.top =s.base+s.stacksize;
s.stacksize +=STACKIN;
}
*s.top++=e;
return 1;
}
int pop(stack &s,int &e)
{
if (s.top ==s.base)return 0;
e=*–s.top;
return 1;
}
};

void main()
{
stack s;
int result,e=0;
result=s.initstack(s);
if(result==1)
cout<<“建栈成功!”<<endl;
else
cout<<“建栈退步!”<<endl;
for(int i=0;i<5;i++)
result=s.push(s,i);
if(result==1)
cout<<“最初化栈成功!”<<endl;
else
cout<<“开始化栈退步!”<<endl;
s.gettop(s,e);
cout<<“栈顶成分为:”<<e<<endl;
result=s.pop(s,e);
if(result==1)
cout<<“删除栈顶成分成功!”<<endl;
else
cout<<“删除栈顶成分退步!”<<endl;
s.pop(s,e);
cout<<“删除的栈顶元素为:”<<e<<endl;
}

/*
3、编写大器晚成函数print,打字与印刷三个上学的小孩子的大成数组,该数组中有5个学子的数据记录,每一种记录富含num、name、score[3],用主函数输入这一个记录,用print函数输出那么些记录。
  
4、在上题的根基上,编写三个函数input,用来输入5个学子的数目记录。*/
#include <string.h>
#include <iostream.h>

struct student
{
public:
int num;
char name[20];
int score[3];
};

class contral
{
public:
void print(struct student *p,int count);
int input(struct student *p,int count);
};

void contral::print(struct student *p,int count)
{
for(int i=0;i<=count;i++)
{
cout<<“Num:”<<p->num<<endl;
cout<<“Name:”<<p->name<<endl;
cout<<“JAVA:”<<p->score[0]<<endl;
cout<<“C++:”<<p->score[1]<<endl;
cout<<“English:”<<p->score[2]<<endl;
p++;
}
}

int contral::input(struct student *p,int count)
{
while(true)
{
cout<<“请输入学号:”<<endl;
cin>>p->num;
cout<<“请输入人名:”<<endl;
cin>>p->name;
cout<<“请输入JAVA分数:”<<endl;
cin>>p->score[0];
cout<<“请输入C++分数:”<<endl;
cin>>p->score[1];
cout<<“请输入English分数:”<<endl;
cin>>p->score[2];
p++;
count++;
cout<<“输入Q退出,输入任何继续”<<endl;
char str[8];
cin>>str;
if(strcmp(str, “q”)==0)
{
break;
}
}
return count;
}

void main()
{
int count=0;
contral con;
student NewS[100];
student *p=NewS;
count=con.input(p,count);
cout<<count<<endl;
con.print(p,count-1);
}

/* 5、将二个链表按逆序排列,将在链头当链尾,链尾当链头。*/
#include<iostream.h>

struct num
{
int data;
struct num *next;
};

void fan(struct num  node1[])
{

for(int i=9;i>=0;i–)
{
node1[i].next=&node1[i-1];
}
}

void main()
{
     struct num  node[10];
     for(int i=0;i<10;i++)
{
       node[i].data=i;
}
     for(int j=0;j<10;j++)
cout<<node[j].data;
     fan(node);
cout<<endl;
cout<<node[9].data;
     for(int k=9;k>0;k–)
cout<<(node[k].next)->data;
}
第8章   类和指标

/*1、自定义叁个字符串处理类CString,且能落到实处取子串、删除子串的法力。*/
#include<iostream.h>

#define MAX_LENGTH 100

class CString
{
public:
void cpystring(char *str);
void getSubstring(int beginStr,int endStr);
void delSubstring(int beginStr,int endStr);
void print();
private:
char cstr[MAX_LENGTH];
int length;
};

#include”CString.h”
#include”string.h”

void CString::cpystring(char *str)
{
int i=0;
while(*str!=’’)
{
cstr[i++]=*str;
str++;
}
cstr[i]=’’;
}

void CString::getSubstring(int beginStr,int endStr)
{
int i,j=0;
char pstr[MAX_LENGTH];
if(beginStr<0||endStr>MAX_LENGTH||beginStr>endStr)
{
cout<<“error!”<<endl;
}
for(i=beginStr;i<endStr;i++,j++)
{
pstr[j]=cstr[i];
}
pstr[j]=’’;
cpystring(pstr);
}

void CString::delSubstring(int beginStr,int endStr)
{
int i,j=0;
char pstr[MAX_LENGTH];
if(beginStr<0||endStr>MAX_LENGTH||beginStr>endStr)
{
cout<<“error!”<<endl;
}
for(i=0;i<beginStr;i++,j++)
{
pstr[j]=cstr[i];
}
for(i=endStr+1;i<strlen(cstr);i++,j++)
{
pstr[j]=cstr[i];
}
pstr[j]=’’;
cpystring(pstr);
}

void CString::print()
{
cout<<cstr<<endl;
}

#include<iostream.h>
#include”CString.h”

main ()
{
CString str1,str2,str3;
str1.cpystring(“Just like before, it’s yesterday once
more!”);//初始化str1
str2=str1;
str3=str1;
str2.getSubstring(5,9卡塔尔(قطر‎;//截取字符串
str3.delSubstring(10,16卡塔尔;//删除字符串
str1.print();
str2.print();
str3.print();
}

/*2、定义一个循环队列类,且完成其毛将焉附相辅相成的分子操作函数,并实例化调用之。*/
CircularQueue.h文件:
*********************************************************************
#define MAX_SIZE 101

class CircularQueue
{
private:
int queue[MAX_SIZE];
int front;
int rear;

public:
CircularQueue();
virtual ~CircularQueue();
bool isEmpty();
bool isFull();
bool push(int);
int pop();
};
*********************************************************************

CircularQueue.cpp文件:
*********************************************************************
#include “CircularQueue.h”

CircularQueue::CircularQueue()
{
front = 0;
rear = 0;
}

CircularQueue::~CircularQueue()
{

}

bool CircularQueue::isFull()
{
if ((rear+1)%MAX_SIZE == front)
{
return true;
}
else
{
return false;
}
}

bool CircularQueue::isEmpty()
{
if (rear == front)
{
return true;
}
else
{
return false;
}
}

bool CircularQueue::push(int e)
{
if (isFull())
{
return false;
}

queue[rear] = e;
rear = ++rear % MAX_SIZE;
return true;
}

CircularQueue::pop()
{
if (isEmpty())
{
return 0;
}

int e = queue[front];
front = ++front % MAX_SIZE;
return e;
}
*********************************************************************

main.cpp文件
*********************************************************************
#include “CircularQueue.h”
#include <iostream>

using namespace std;

void main()
{
CircularQueue cQueue;
for (int i=0 ; i<75; i++)
{
cQueue.push(i);
}

for (i=0; i<50; i++)
{
cout << cQueue.pop() << ” “;
}
cout << endl;

for (i=0; i<60; i++)
{
cQueue.push(i);
}

for (i=0; i<85; i++)
{
cout << cQueue.pop() << ” “;
}
cout << endl;
}
*********************************************************************
第9章   运算符重载

/*1、定义八个二维向量类Vector,并在那类中用成员函数方式重载一元运算符++(前、后缀)和二元运算符+。*/
class Vector
{
public:
Vector();
Vector(int x,int y);
operator ++();
Vector operator ++(int);
Vector operator +(const Vector &a);
void display();
private:
int x,y;
};

#include<iostream.h>
#include”Vector.h”

Vector::Vector(){}
Vector::Vector(int x,int y)
{
this->x=x;
this->y=y;
}
Vector::operator ++() {++x;++y;}
Vector Vector::operator ++(int)
{
Vector s;
s.x=x++;
s.y=y++;
return s;
}
Vector Vector::operator +(const Vector &v)
{
Vector sum;
sum.x=x+v.x;
sum.y=y+v.y;
return sum;
}
void Vector::display()
{
cout<<“(“<<x<<“,”<<y<<“)”<<endl;
}

#include<iostream.h>
#include”Vector.h”

void main()
{
Vector v1(3,4),v2(1,2),v3;
cout<<“v1=”;v1.display();
cout<<“v2=”;v2.display();
++v1;
cout<<“++v1=”;v1.display();
cout<<“v2++=”;(v2++).display();
cout<<“v2=”;v2.display();
v3=v1+v2;
cout<<“v1+v2=”;v3.display();
}

/*2、将首先题中的相关重载项改为用友元函数的秘籍重载。*/
class Vector
{
public:
Vector();
Vector(int x,int y);
friend void operator ++(Vector &v);
friend void operator ++(Vector &v,int);
friend Vector operator +(const Vector &v1,const Vector &v2);
void display();
private:
int x,y;
};

#include<iostream.h>
#include”Vector.h”

Vector::Vector(){}
Vector::Vector(int x,int y)
{
this->x=x;
this->y=y;
}
void operator ++(Vector &v) {++v.x;++v.y;}
Vector operator ++(Vector &v,int)
{
Vector before(v.x,v.y);
v.x++;
v.y++;
return before;
}
Vector operator +(const Vector &v1,const Vector &v2)
{
Vector sum;
sum.x=v1.x+v2.x;
sum.y=v1.y+v2.y;
return sum;
}
void Vector::display()
{
cout<<“(“<<x<<“,”<<y<<“)”<<endl;
}

#include<iostream.h>
#include”Vector.h”

void main()
{
Vector v1(3,4),v2(1,2),v3;
cout<<“v1=”;v1.display();
cout<<“v2=”;v2.display();
++v1;
cout<<“++v1=”;v1.display();
cout<<“v2++=”;(v2++).display();
cout<<“v2=”;v2.display();
v3=v1+v2;
cout<<“v1+v2=”;v3.display();
}

/*3、重载字符串处理类CString的“=”号和“+”号运算符。*/
class Cstring
{
public:
Cstring(char *pn);
~Cstring();
Cstring& operator=(Cstring &c);
Cstring& operator+(Cstring &c);
void display();
private:
char *p;
};

#include<iostream.h>
#include<string.h>
#include”Cstring.h”

Cstring::Cstring(char *pn)
{
p=new char[strlen(pn)+1];
strcpy(p,pn);
}

Cstring::~Cstring()
{
delete []p;
}

Cstring& Cstring::operator=(Cstring &s)
{
delete []p;
p=new char[strlen(s.p)+1];
strcpy(p,s.p);
return *this;
}

Cstring& Cstring::operator+(Cstring &s)
{
char *pp = new char[strlen(p)+strlen(s.p)+1];
strcpy(pp,p);
strcat(pp,s.p);
delete []p;
p = pp;
return *this;
}

void Cstring::display()
{
cout<<p<<endl;
}

#include<iostream.h>
#include <string.h>
#include”Cstring.h”

void main()
{
Cstring s1(“first hello”);
Cstring s2(“second hello”);
cout<<“赋值早先:”<<endl;
cout<<“s1=”;
s1.display();
cout<<“s2=”;
s2.display();
cout<<“赋值之后:”<<endl;
s1=s2;
cout<<“s1=”;
s1.display();
cout<<“s2=”;
s2.display();
cout<<“相加之后:”<<endl;
cout<<“s1+s2″<<endl;
(s1+s2).display();
}
第11章 继承和派生类

/*1、利用虚基类,祛除“两性人”中的冗余数据:姓名、年龄,并编制程序达成之。*/
class Person 
{
public:
Person(char *name,int age);
Person();
virtual ~Person();

protected:
int age;
char name[20];
};

#include “Person.h”
#include <string.h>

Person::Person(char *name, int age)
{
strcpy(this->name,name);
this->age = age;
}

class Man: virtual public Person
{
public:
Man(char *name,int age,char *sex);
Man();
virtual ~Man();

protected:
char sex[8];
};

#include “Man.h”
#include “Person.h”
#include <string.h>

Man::Man(char *name,int age,char *sex):Person(name,age)
{
strcpy(this->sex,sex);
}

#include”Person.h”

class Woman: virtual public Person 
{
public:
Woman(char *name,int age,char *sex);
Woman();
virtual ~Woman();

protected:
char sex[8];
};

#include “Woman.h”
#include “Person.h”
#include <string.h>

Woman::Woman(char *name,int age,char *sex):Person(name,age)
{
strcpy(this->sex,sex);
}

class Transexual:public Man,public Woman
{
public:
print();
Transexual(char *name, int age, char *sex1,char *sex2);
Transexual();
virtual ~Transexual();

};

#include “Transexual.h”
#include “Man.h”
#include “Woman.h”
#include “Person.h”
#include <iostream.h>

Transexual::Transexual(char *name, int age, char *sex1,char
*sex2):Person(name,age),Man(name,age,sex1),Woman(name,age,sex2)
{

}

Transexual::print()
{
cout<<“姓名:”<<name<<endl;
cout<<“年龄:”<<age<<endl;
cout<<“性别:”<<Man::sex<<”
“<<Woman::sex<<endl;
}

/*2、通过Point类派生出Circle和Rectangle类,再经过Circle和Rectangle派生出“足体育场图形”类Football,并实例化调用Football这么些类,且用cout打字与印刷追踪全体类的布局函数和析构函数的调用进度。(注:上面是那多少个类的图形描述,且需求每一个类都重载构造函数,且都无须暗中同意布局函数)*/
#include<iostream.h>

class Point{
public:
Point(double x){
this->x=x;
cout<<“Point Constructor called”<<endl;
}
~Point(){
cout<<“Point Destructor called”<<endl;
}
protected:
double x;
};

#include<iostream.h>
#define PI 3.14159265

class Circle:virtual public Point{
public:
Circle(double x):Point(x){
cout<<“Circle Constructor called”<<endl;
}
~Circle(){
cout<<“Circle Destructor called”<<endl;
}
void setCarea(){
carea=PI*x/2*x/2;
}
double getCarea(){
return carea;
}
protected:
double carea;

};

#include<iostream.h>

class Rectangle:virtual public Point{
public:
Rectangle(double x,double y):Point(x){
this->y=y;
cout<<“Rectangle Constructor called”<<endl;
}
~Rectangle(){
cout<<“Rectangle Destructor called”<<endl;
}
void setRarea(){
rarea=x*y;
}
double getRarea(){
return rarea;
}
protected:
double y,rarea;
};

#include<iostream.h>
#define PI 3.14159265

class Football:public Circle,public Rectangle{
public:
Football(double x,double y):Point(x),Circle(x),Rectangle(x,y){
cout<<“Football Constructor called”<<endl;
}
~Football(){
cout<<“Football Destructor called”<<endl;
}
void setFarea(){
farea=x*y+PI*x/2*x/2;
}
double getFarea(){
return farea;
}
protected:
double farea;
};

#include<iostream.h>
#include”Point.h”
#include”Circle.h”
#include”Rectangle.h”
#include”Football.h”

void main(){
Circle c(10);
Rectangle r(10,20);
Football f(10,20);
c.setCarea();
r.setRarea();
f.setFarea();
cout<<“Circle area:”<<c.getCarea()<<endl;
cout<<“Rectangle area:”<<r.getRarea()<<endl;
cout<<“Football area:”<<f.getFarea()<<endl;
}
第12章   模板

/*1、利用C++的模板机制定义单向队列类模板、链表类模板,并实例化应用之。*/
/*单向队列类模板*/
#define MAX_SIZE 50

template<class T>
class Temqueue
{
private:
T queue[MAX_SIZE];
T front;
T rear;

public:
Temqueue();
virtual ~Temqueue();
bool isEmpty();
bool isFull();
bool push(T);
T pop();
};

template<class T>
Temqueue<T>::Temqueue()
{
front = 0;
rear = 0;
}

template<class T>
Temqueue<T>::~Temqueue()
{

}

template<class T>
bool Temqueue<T>::isFull()
{
if ((rear-MAX_SIZE) == front)
{
return true;
}
else
{
return false;
}
}

template<class T>
bool Temqueue<T>::isEmpty()
{
if (rear == front)
{
return true;
}
else
{
return false;
}
}

template<class T>
bool Temqueue<T>::push(T e)
{
if (isFull())
{
return true;
}
queue[rear] = e;
rear = ++rear;
return true;
}

template<class T>
T Temqueue<T>::pop()
{
if (isEmpty())
{
return true;
}
T e = queue[front];
front = ++front;
return e;
}

#include “Temqueue.h”
#include <iostream>

using namespace std;

void main()
{
int k;
cout<<“请输入要给数列开首化的长度,队列长度为50。”<<endl;
cin>>k;
Temqueue<int> cQueue;
for (int i=0 ; i<k; i++)
{
cQueue.push(i);
}
if(k>0)
{
for (i=0; i<k; i++)
{
if (i>=MAX_SIZE)
{
cout<<“队列已满!”<<endl;
break;
}
else
cout<<cQueue.pop()<< ” “;
}
cout<<endl;
}
else
cout<<“队列为空!”<<endl;
}

/*链表类模板*/
template<typename T> class List;     //对List类的申明
template<typename T> class Node{     //定义三个叙述节点的类
public:
Node();
friend class List<T>;
private:
T data;
Node<T> * next;
};

template<typename T>Node<T>::Node(){
data=0;
next=NULL;
}

template<typename T>class List{                    
//定义多个描述链表的类
public:
List(卡塔尔;                                        
//空链表的协会(链表中只含表头结点)
~List(State of Qatar;                                        //析构函数
void MakeEmpty(卡塔尔(قطر‎;                              
//清空链表(删除链表中除表头结点以外的持有结点)
Node<T> * Find(T d卡塔尔;                           
//查找数据域与d相像的结点(重临所找到结点的指针)
void PrintList(卡塔尔;                              
//输出链表中各结点的数据域
void CreateList(卡塔尔国; //伊始化链表
private:
Node<T> * head,* rear;
};

template<typename T>List<T>::List(){
head=rear=new Node<T>;
}

template<typename T>void List<T>::MakeEmpty(){
Node<T> *temp;
while(head->next!=NULL){
temp = head->next ;
    head->next = temp->next ;
   delete temp ;
}
rear = head;
}

template<typename T>List<T>::~List(){
MakeEmpty();
delete head;
}

template<typename T>void List<T>::PrintList(){
rear = head->next;
while(rear!=NULL){
cout<<rear->data<<endl ;
rear = rear->next ;
}
}

template<typename T>void List<T>::CreateList(){
T d;
cout<<“今后初叶创办链表,请依次输入数据(以Ctrl+Z甘休):”<<endl;
while(cout<<“请输入:” && cin>>d){
rear->next=new Node<T>;
   rear->next->data=d;
   rear=rear->next;
   rear->next=NULL;
}
}

#include <iostream>
#include “Node.h”
#include “List.h”
using namespace std;

void main(){
List <int>l;
    l.CreateList();
l.PrintList();
cout<<“over!”<<endl;
}

/*2、定义一个类模板,然后生成其模板类并定义该类模板的派生类模板和派生类。*/
using namespace std;

template <class T>
class Te{
public:
T te;
};

template <class T>
class Tte:public Te<T>{
public:
T tte;
};

class Fte:public Te<int>{
public:
int fte;
};

#include<iostream>
#include”Te.h”
#include”Tte.h”
#include”Fte.h”

void main(){
Te<int> te;
te.te=10;
cout<<“te=”<<te.te<<endl;
Tte<int> itte;
itte.tte=20;
cout<<“itte=”<<itte.tte<<endl;
Tte<double> dtte;
dtte.tte=3.14;
cout<<“dtte=”<<dtte.tte<<endl;
Fte fte;
fte.fte=10;
cout<<“fte=”<<fte.fte<<endl;
}
第13章 多态性与虚函数

/*1、利用虚函数,实现triangle(三角形),square(矩形),circle(圆)的面积计算函数show_area。*/
using namespace std;

class Shape{
public:
virtual double show_area()=0;
virtual char* shapeName()=0;
};

class Circle:public Shape{
public:
Circle(double radius){
this->radius=radius;
}
virtual double show_area(){
return 3.14*radius*radius;
}
virtual char* shapeName(){
return “Circle: “;
}
protected:
double radius;
};

class Square:public Shape{
public:
Square(double length,double width){
this->length=length;
this->width=width;
}
virtual double show_area(){
return length*width;
}
virtual char* shapeName(){
return “Square: “;
}
protected:
double length,width;
};

class Triangle:public Shape{
public:
Triangle(double length,double height){
this->length=length;
this->height=height;
}
virtual double show_area(){
return length*height/2;
}
virtual char* shapeName(){
return “Triangle: “;
}
protected:
double length,height;
};

#include<iostream>
#include”Shape.h”
#include”Circle.h”
#include”Square.h”
#include”Triangle.h”

void main(){
Shape *ptr;
Circle circle(10);
Square square(10,15);
Triangle triangle(10,15);
ptr=&circle;
cout<<ptr->shapeName()<<ptr->show_area()<<endl;
ptr=□
cout<<ptr->shapeName()<<ptr->show_area()<<endl;
ptr=▵
cout<<ptr->shapeName()<<ptr->show_area()<<endl;
}

/*2、将圆类circle的乘除面积和测算周长的作用分别抽象成class area和class
perimeter,并在这里三个新类中选取纯虚函数功用完结面积和周长的联合调用接口展现函数Show。*/
using namespace std;

class Circle{
public:
Circle(double radius){
this->radius=radius;
}
virtual double show()=0;
virtual char* shapeName()=0;
protected:
double radius;
};

class Area:public Circle{
public:
Area(double radius):Circle(radius){
}
virtual double show(){
return 3.14*radius*radius;
}
virtual char* shapeName(){
return “Circle Area: “;
}
};

class Perimeter:public Circle{
public:
Perimeter(double radius):Circle(radius){
}
virtual double show(){
return 2*3.14*radius;
}
virtual char* shapeName(){
return “Circle Perimeter: “;
}
};

#include<iostream>
#include”Circle.h”
#include”Area.h”
#include”Perimeter.h”

void main(){
Circle *ptr;
Area area(10);
Perimeter perimeter(10);
ptr=&area;
cout<<ptr->shapeName()<<ptr->show()<<endl;
ptr=&perimeter;
cout<<ptr->shapeName()<<ptr->show()<<endl;
}
第14章  I/O流

1、创设二个二进制文件,并对其进展种种操作。
struct i_Data //种种学员记录含准考证号、姓名、斯洛伐克语成绩共3个字段
{
char ID[30];
char name[30];
int score;
};

#include “i_Data.h”
#define NUM 2

class Io{
public:
void input(){
fstream infile;
int i;
infile.open(“score.dat”,ios::out|ios::binary);
if(!infile){
cout<<“score.dat can’t writed.n”;
abort();
}
for(i=0;i<NUM;i++){
cout<<“请输入第”<<i+1<<“位考生音讯:n”;
cout<<“input 准考证号:”;
cin>>data[i].ID;
cout<<“input 姓名:”;
cin>>data[i].name;
cout<<“input 波兰语战绩:”;
cin>>data[i].score;
cout<<endl;
infile.write((char *) &data[i], sizeof(data[i]));
}
infile.close();
system(“cls”);
}

void output(){
fstream outfile;
int i;
outfile.open(“score.dat”,ios::in|ios::binary);
if(!outfile){
cout<<“score.dat can’t opened.n”;
abort();
}
for(i=0;i<NUM;i++){
outfile.read((char *) &data[i], sizeof(data[i]));
cout<<“第”<<i+1<<“位考生消息为:n”;
cout<<“准考证号:”<<data[i].ID<<endl;
cout<<“姓名:”<<data[i].name<<endl;
cout<<“罗马尼亚语成绩:”<<data[i].score<<endl;
cout<<endl;
}
outfile.close();
}
private:
struct i_Data data[NUM];
};

#include <iostream>
#include <fstream.h>
#include <stdlib.h>
#include “Io.h”
#define NUM 2

void main() {
Io io;
io.input(卡塔尔国; //写入文件
io.output(卡塔尔; //读取文件
}
第15章   万分管理

1、自身写一个前后相继,在某种条件下抛出各种类型卓殊(如:整数、字符串、类对象、援用等),再捕捉这几个特别,并进行连锁处理,保障本人的顺序不被中止,让它继续实行。
#include<iostream>
#include<string>
using namespace std;

class String{
public:
String(char*, int);
class Range{ //异常类1
public:Range(int j):index(j){}
int index;
};
class Size{}; //异常类2
char& operator[](int k){
if(0<=k && k<len)
return p[k];
        throw Range(k);
}
private:char* p;
int len;
static int max;
};

int String::max = 20;
String::String(char* str, int si){
if(si<0 || max<si)
   throw Size();
p=new char[si];
strncpy(p, str, si);
len=si;
}

void g(String& str){
int num=10;
for(int n=0; n<num; n++)
   cout <<str[n];
cout <<endl;
}

void f()
{
//代码区1
try{
//代码区2
String s(“abcdefghijklmnop”, 10);
g(s);
}
catch(String::Range r)
{
cerr <<“->out of range: ” <<r.index <<endl;
//代码区3
}
catch(String::Size)
{
cerr <<“size illegal!n”;
}
cout <<“The program will be continued here.nn”;
//代码区4
}

void main()
{
//代码区5
f();
cout <<“These code is not effected by probably exception in
f().n”;
}
/*小张同学看来您的一本Java书上写着“Object无处不在”,真的是那样吗?他一眼扫到写字台上风姿浪漫盏可调亮度的台灯。能够用Java表现台灯吗?他请你尝试看。基本须要:
1、编写台灯类,台灯具有按钮状态和“规范”、“增强”两档可调亮度;台灯具有开辟、关闭成效,并能够安装亮度档位;
2、编写主类,显示台灯调控菜单,客户能够借助菜单选项决定不住调节意气风发盏台灯的意况;
3、接纳调控菜单的“退出”选项能够甘休程序运维。*/
using namespace std;

class Light{
public:
Light();
void setStatus(bool status);
bool getStatus();
void setBright(int bright);
int getBright();
void setStyle(int style);
int getStyle();
int input();
void output();
private:
bool status;//表状态:开启或然关闭
int bright;//表亮度
int style;//表亮度类型:普通也许升高
};

#include<iostream>
#include”Light.h”

void Light::setStatus(bool status){
this->status=status;
}

Light::Light(){
status=false;
bright=3;
style=0;
}

bool Light::getStatus(){
return status;
}

void Light::setBright(int bright){
this->bright=bright;
}

int Light::getBright(){
return bright;
}

void Light::setStyle(int style){
this->style=style;
}

int Light::getStyle(){
return style;
}

int Light::input(){
cout<<“请输入你要输入的值:”;
int res=-1;//再次来到输入的值,
cin>>res;
if(cin.fail()){
cout<<“输入的数额超过范围!”;
exit(0State of Qatar;//程序退出
}
return res;
}

void Light::output(){
cout<<“当前电灯系统状态为–“<<(this->getStatus(State of Qatar?”开启”:”关闭”卡塔尔国<<“,亮度类型为–“
<<(this->getStyle(卡塔尔==1?”增强”:”标准”卡塔尔<<“,亮度档位为–“<<this->bright<<endl;
}

#include<iostream>
#include”Light.h”

void main(){
Light light;
do{
cout<<“—————<Control
Menu>—————–“<<endl;
cout<<“1-开灯,2-调整状态,3-调度亮度,4-关灯”<<endl;
cout<<“———————————————-“<<endl;
int answer=light.input();
if(answer==1){
light.setStatus(true);
cout<<“系统启用中。。。”<<endl;
light.output();
}
else if(answer==2){
if(!light.getStatus()){
cout<<“警告!系统还没运维!操作战败!”<<endl;
continue;
}
do{
cout<<“请输入你要调治的情状(0-标准,1-巩固卡塔尔(قطر‎:”<<endl;
int style=light.input();
if(style==0 || style==1){
cout<<“操作成功!”<<endl;
light.setStyle(style);
light.output();
break;
}
else{
cout<<“您输入的值超过了增选范围!请重新输入!”<<endl;
continue;
}
}while(true);
}
else if(answer==3){
if(!light.getStatus()){
cout<<“警告!系统尚未运维!操作战败!”<<endl;
continue;
}
do{
cout<<“请输入你要调治的亮度(1–5卡塔尔国:”<<endl;
int bright=light.input();;
if( bright>=0 &&  bright<=5){
cout<<“操作成功!”<<endl;
light.setBright(bright);
light.output();
break;
}
else{
cout<<“您输入的值超越了增选范围!请重新输入!”<<endl;
continue;
}
}while(true);
}
else if(answer==4){
if(!light.getStatus()){
cout<<“警告!系统绝非运行!操作失败!”<<endl;
continue;
}
cout<<“系统将要关张!”<<endl;
light.setStatus(false);
break;
}
else {
cout<<“您输入的值大于了选取范围!请重新输入!”<<endl;
}
}while(true);
}

/*万年历*/
#include<iostream.h>
#include<stdlib.h>
#include<iomanip.h>
void main()
{
int year,month,startyear,today,day0,day1,k,j;
char a,b,c;
int M[12]={31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
int M0[12]={ 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };

    do{
do{
cout<<“请输入年份(1987-2020卡塔尔(قطر‎:”;
cin>>year;
if(year<1990||year>2020){
cout<<“您输入的年度越界,是或不是再一次输入(Y/N||y/nState of Qatar?”;
cin>>a;
if(a==’Y’||a==’y’){
continue;}
else exit(0);
}
else{break;}
}while(true);
do{
cout<<“请输入月份(1-12卡塔尔(قطر‎:”;
cin>>month;
if(month<1||month>12){
cout<<“您输入的月度越界,是还是不是再次输入(Y/N||y/n卡塔尔(قطر‎?”;
cin>>b;
if(b==’Y’||b==’y’){
continue;}
else{exit(0);}
}
else{break;}
}while(true);
//总结有效天数
day0=0;
day1=0;
j=0;
startyear=1990;
    while (startyear != year)
{
     if ((startyear%4==0&&startyear%100!=0)||(startyear%400==0))
         day0 = day0 + 366;
     else
         day0 = day0 + 365;
     startyear++;
}
if((year%4==0&&year%100!=0)||(year%400==0)){
for (int i = 0; i < (month – 1); i++)
            day1 = day1 + M0[i];
            today = day0 + day1;
}
else{
for (int i = 0; i < (month – 1); i++)
            day1 = day1 + M[i];
            today = day0 + day1;
}
//输出部分

//闰年出口 
if((year%4==0&&year%100!=0)||(year%400==0)){
cout<<year<<“年”<<month<<“月份的日历如下”<<endl;
cout<<setw(30)<<endl;
cout << setw(8) << “Sun”;
        cout << setw(8) << “Mon”;
        cout << setw(8) << “Tue”;
        cout << setw(8) << “Wed”;
        cout << setw(8) << “Thu”;
        cout << setw(8) << “Fri”;
        cout << setw(8) << “Sat”;
        cout << endl;
k=(today%7+1)%7;
for(int i=1; i<=k; i++)
cout<<setw(8)<<“”;
for(int g=1; g<=(7-k); g++){
cout<<setw(8)<<g;
}
cout<<endl;
for(int h=8-k; h<=M0[month-1]; h++) {
cout<<setw(8)<<h;
j++;
if(j==7){
j=0;
cout<<endl;
}
}
}
//平年出口
else {
cout<<year<<“年”<<month<<“月份的日历如下”<<endl;
cout<<setw(30)<<“”<<endl;
cout << setw(8) << “Sun”;
        cout << setw(8) << “Mon”;
        cout << setw(8) << “Tue”;
        cout << setw(8) << “Wed”;
        cout << setw(8) << “Thu”;
        cout << setw(8) << “Fri”;
        cout << setw(8) << “Sat”;
        cout << endl;
k=(today%7+1)%7;
for(int i=1; i<=k; i++)
cout<<setw(8)<<“”;
for(int g=1; g<=(7-k); g++){
cout<<setw(8)<<g;
}
cout<<endl;
for(int h=8-k; h<=M[month-1]; h++) {
cout<<setw(8)<<h;
j++;
if(j==7){
j=0;
cout<<endl;
}
}
}
cout<<endl;
cout<<“是还是不是两次三番输入(Y/N||y/n卡塔尔(قطر‎?”;
cin>>c;
if(c==’Y’||c==’y’) continue;
else exit(0);
}while(true);
}

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图