C和指针课后习题(第六章)

45 篇文章 2 订阅
31 篇文章 0 订阅

6.1

#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
char *find_char(char const *source,char const *chars)
{
	int source_len = 0,chars_len = 0;
	int i = 0,j = 0;
	char ch;
	while(*(source+i++)!='\0')
		source_len++;
	while(*(chars+j++)!='\0')
		chars_len++;
	for (i=0;i<source_len;i++)
	{
		for (j=0;j<chars_len;j++)
		{
			if (*(chars+j)==*(source+i))
			{
				ch = *(chars+j);
				return &ch;
			}
		}
	}
	return NULL;
}

int main()
{
	const char *source = "china";
	const char *chars = "America";
	char ch;
	ch = *find_char(source,chars);
	printf("%c\n",ch);
	system("pause");
	return 0;
}

6.2

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
int del_substr(char *str,const char *substr)
{
	int str_len = 0;
	int sub_len = 0;
	int i =0,j=0,k;
	while(*(str+i++)!='\0')
		str_len++;
	while(*(substr+j++)!='\0')
		sub_len++;
	assert(str_len>=sub_len);
	char *p1 = str;
	const char *p2 = substr;
#if 0
	printf("str_len=%d\nsub_len=%d\n",str_len,sub_len);
#endif
	for(i=0;i<=(str_len-sub_len);i++)
	{
		k = i;
#if 0
		printf("%c\t",*(p1+i));
#endif
		for (j=0;j<sub_len;j++)
		{
			if (*(p1+k++)!=*(p2+j))
				break;
		}
		if (j==sub_len)
			return 1;
	}
	return 0;
}

int main()
{
	char *str = "ABCDEFG";
	char *substr = "CDE";
	printf("result is %d\n",del_substr(str,substr));
	system("pause");
	return 0;
}

6.3

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#define max_line 128
void reverse_string(char *string)
{
	char *p = string;
	int i=0;
	int string_len = 0;
	while(*(p+i++)!='\0')
	{
		string_len++;
	}
	assert(string_len>0);
	printf("the original string is \n%s\n",string);
#if 1
	printf("string_len = %d\n",string_len);
#endif
	printf("the reverse string is\n");
	for (int i=string_len-1;i>=0;i--)
	{
		printf("%c",string[i]);
	}
	printf("\n");
}
int main()
{
	char *string;
	printf("please input a string:\n");
	string = (char *)malloc(sizeof(char)*max_line);
	gets(string);
	reverse_string(string);
	system("pause");
	return 0;
}

6.4

#include <stdio.h>
#include <stdlib.h>
#define MAX 1000
#include <time.h>
int main(void)
{
	int i;
	int j;
	char table[MAX];
	double time = 0.00;
	clock_t start = 0,end = 0;
	start = clock();
	for(i = 2;i < MAX;i++)
		table[i] = 1;
	for(i = 2;i < MAX;i++)
		if(table[i] == 1)
			for(j = i;i*j < MAX;j++)
				table[i*j] = 0;
	for(i = 2;i < MAX;i++)
		if(table[i] == 1)
			printf("%d\n",i);
	end = clock();
	time = (double)(end-start)/CLOCKS_PER_SEC;
	printf("time eclipse is %lf\n",time);
	system("pause");
	return 0;
}

6.6

#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#define MAX 1000
#include <time.h>
#include <string.h>
int main(void)
{
	int i,k;
	//unsigned int j;
	int j,number1=0,number2=0,number=0 ;
	char table2[2000];
	double time = 0.00;
	clock_t start = 0,end = 0;
	start = clock();
	for (j=1000;j<=40000;j+=1000)
	{
		number1 = 0;
		char *table = (char *)malloc(sizeof(char)*j);
		printf("strlen=%d\n",strlen(table));

		for(i = 2;i < j;i++)
			table[i] = 1;
		for(i = 2;i < j;i++)
			if(table[i] == 1)
				for(k = i;i*k < j;k++)
					table[i*k] = 0;
		for(i = 2;i < j;i++)
			if(table[i] == 1)
			{
				//printf("%d\n",i);
				number1++;
			}
			printf("number1=%d\n",number1);
			printf("the prime number between %d and %d is %d\n",j-1000,j,number1-number);
			number = number1;
	}
	//char table1[MAX];
	
	
	
#if 0
		for(i = 2;i < 2000;i++)
			table2[i] = 1;
		for(i = 2;i < 2000;i++)
			if(table2[i] == 1)
				for(j = i;i*j < 2000;j++)
					table2[i*j] = 0;
		for(i = 2;i < 2000;i++)
			if(table2[i] == 1)
			{
				//printf("%d\n",i);
				number2++;
			}
			printf("number2=%d\n",number2);
			//printf("the prime number between 1000 and 2000 is %d\n",number2-number1);
#endif
		end = clock();
		time = (double)(end-start)/CLOCKS_PER_SEC;
		printf("time eclipse is %lf\n",time);
		int  num=0;
		for (i=29000;i<30000;i++)
		{
			for (j=2;j<i;j++)
			{
				if (i%j==0)
					break;
			}
			if (j==i)
				num++;
		}
		printf("num=%d\n",num);
		system("pause");
		return 0;
}

6.6这个程序有一个问题,就是数字如果在大的话会出现 Access violation writing location 0x80aa1701这个错误,我现在还没有搞明白为什么会出现这个错误,我怀疑是不是由于申请的空间太大导致这个问题的出现,有没有大神出来解释一下,如果使用我在程序中的最后面的那种简单的耗时的方法很容易求出来没有什么问题

如果有时间的将结果写入到文本中,待续!!!

  • 3
    点赞
  • 15
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
第 一 章 概述 1-1 简述计算机程序设计语言的发展历程。 解: 迄今为止计算机程序设计语言的发展经历了机器语言、汇编语言、高级语言等阶段,C++语言是一种面向对象的编程语言,也属于高级语言。 1-2 面向对象的编程语言有哪些特点? 解: 面向对象的编程语言与以往各种编程语言有根本的不同,它设计的出发点就是为了能更直接的描述客观世界中存在的事物以及它们之间的关系。面向对象的编程语言将客观事物看作具有属性和行为的对象,通过抽象找出同一类对象的共同属性(静态特征)和行为(动态特征),形成类。通过类的继承与多态可以很方便地实现代码重用,大大缩短了软件开发周期,并使得软件风格统一。因此,面向对象的编程语言使程序能够比较直接地反问题域的本来面目,软件开发人员能够利用人类认识事物所采用的一般思维方法来进行软件开发。C++语言是目前应用最广的面向对象的编程语言。 1-3 什么是结构化程序设计方法?这种方法有哪些优点和缺点? 解: 结构化程序设计的思路是:自顶向下、逐步求精;其程序结构是按功能划分为若干个基本模块;各模块之间的关系尽可能简单,在功能上相对独立;每一模块内部均是由顺序、选择和循环三种基本结构组成;其模块化实现的具体方法是使用子程序。结构化程序设计由于采用了模块分解与功能抽象,自顶向下、分而治之的方法,从而有效地将一个较复杂的程序系统设计任务分解成许多易于控制和处理的子任务,便于开发和维护。 虽然结构化程序设计方法具有很多的优点,但它仍是一种面向过程的程序设计方法,它把数据和处理数据的过程分离为相互独立的实体。当数据结构改变时,所有相关的处理过程都要进行相应的修改,每一种相对于老问题的新方法都要带来额外的开销,程序的可重用性差。 由于图形用户界面的应用,程序运行由顺序运行演变为事件驱动,使得软件使用起来越来越方便,但开发起来却越来越困难,对这种软件的功能很难用过程来描述和实现,使用面向过程的方法来开发和维护都将非常困难。 1-4 什么是对象?什么是面向对象方法?这种方法有哪些特点? 解: 从一般意义上讲,对象是现实世界中一个实际存在的事物,它可以是有形的,也可以是无形的。对象是构成世界的一个独立单位,它具有自己的静态特征和动态特征。面向对象方法中的对象,是系统中用来描述客观事物的一个实体,它是用来构成系统的一个基本单位,由一组属性和一组行为构成。 面向对象的方法将数据及对数据的操作方法放在一起,作为一个相互依存、不可分离的整体--对象。对同类型对象抽象出其共性,形成类。类中的大多数数据,只能用本类的方法进行处理。类通过一个简单的外部接口,与外界发生关系,对象与对象之间通过消息进行通讯。这样,程序模块间的关系更为简单,程序模块的独立性、数据的安全性就有了良好的保障。通过实现继承与多态性,还可以大大提高程序的可重用性,使得软件的开发和维护都更为方便。 面向对象方法所强调的基本原则,就是直接面对客观存在的事物来进行软件开发,将人们在日常生活中习惯的思维方式和表达方式应用在软件开发中,使软件开发从过分专业化的方法、规则和技巧中回到客观世界,回到人们通常的思维。 1-5 什么叫做封装? 解: 封装是面向对象方法的一个重要原则,就是把对象的属性和服务结合成一个独立的系统单位,并尽可能隐蔽对象的内部细节。 1-6 面向对象的软件工程包括哪些主要内容? 解: 面向对象的软件工程是面向对象方法在软件工程领域的全面应用,它包括面向对象的分析(OOA)、面向对象的设计(OOD)、面向对象的编程(OOP)、面向对象的测试(OOT)和面向对象的软件维护(OOSM)等主要内容。 1-7 简述计算机内部的信息可分为几类? 解: 计算机内部的信息可以分成控制信息和数据信息二大类;控制信息可分为指令和控制字两类;数据信息可分为数值信息和非数值信息两类。 1-8 什么叫二进制?使用二进制有何优点和缺点? 解: 二进制是基数为2,每位的权是以2 为底的幂的进制,遵循逢二进一原则,基本符号为0和1。采用二进制码表示信息,有如下几个优点:1.易于物理实现;2.二进制数运算简单;3.机器可靠性高;4.通用性强。其缺点是它表示数的容量较小,表示同一个数,二进制较其他进制需要更多的位数。 1-9 请将以下十进制数值转换为二进制和十六进制补码: (1)2 (2)9 (3)93 (4)-32 (5)65535 (6)-1 解: (1) (2)10 = (10)2 = (2)16 (2) (9)10 = (1001)2 = (9)16 (3) (93)10 = (1011101)2 = (5D)16 (4) (-32)10 = (11100000)2 = (E0)16 (5) (65535)10 = (11111111 11111111)2 = (FFFF)16 (6) (-1)10 = (11111111 11111111)2 = (FFFF)16 1-10 请将以下数值转换为十进制: (1)(1010)2 (2)(10001111)2 (3)(01011111 11000011)2 (4)(7F)16 (5)(2D3E)16 (6)(F10E)16 解: (1)(1010)2 = (10)10 (2)(10001111)2 = (143)10 (3)(01011111 11000011)2 = (24515)10 (4)(7F)16 = (127)10 (5)(2D3E)16 = (11582)10 (6)(F10E)16 = (61710)10 1-11 简要比较原码、反码、补码等几种编码方法。 解: 原码:将符号位数字化为 0 或 1,数的绝对值与符号一起编码,即所谓"符号──绝对值表示"的编码。 正数的反码和补码与原码表示相同。 负数的反码与原码有如下关系: 符号位相同(仍用1表示),其余各位取反(0变1,1变0)。 补码由该数反码的最末位加1求得。 第 二 章 C++简单程序设计 2-1 C++语言有那些主要特点和优点? 解: C++语言的主要特点表现在两个方面,一是全面兼容C,二是支持面向对象的方法。C++是一个更好的C,它保持了C的简洁、高效、接近汇编语言、具有良好的可读性和可移植性等特点,对C的类型系统进行了改革和扩充,因此C++比C更安全,C++的编译系统能检查出更多的类型错误。 C++语言最重要的特点是支持面向对象。 2-2 下列标识符哪些是合法的? Program, -page, _lock, test2, 3in1, @mail, A_B_C_D 解: Program, _lock, test2, A_B_C_D是合法的标识符,其它的不是。 2-3 例2.1中每条语句的作用是什么? #include void main(void) { cout<<"Hello!\n"; cout<<"Welcome to c++!\n"; } 解: #include //指示编译器将文件iostream.h中的代码 //嵌入到该程序中该指令所在的地方 void main() //主函数名,void 表示函数没有返回值 { //函数体标志 cout<<"Hello!\n"; //输出字符串Hello!到标准输出设备(显示器)上。 cout<<"Welcome to c++!\n"; //输出字符串Welcome to c++! } 在屏幕输出如下: Hello! Welcome to c++! 2-4 使用关键字const而不是#define语句的好处有哪些? 解: const定义的常量是有类型的,所以在使用它们时编译器可以查错;而且,这些变量在调试时仍然是可见的。 2-5 请写出C++语句声明一个常量PI,值为3.1416;再声明一个浮点型变量a,把PI的值赋给a。 解: const float PI = 3.1416; float a = PI; 2-6 在下面的枚举类型中,Blue的值是多少? enum COLOR { WHITE, BLACK = 100, RED, BLUE, GREEN = 300 }; 解: Blue = 102 2-7 注释有什么作用?C++中有哪几种注释的方法?他们之间有什么区别? 解: 注释在程序中的作用是对程序进行注解和说明,以便于阅读。编译系统在对源程序进行编译时不理会注释部分,因此注释对于程序的功能实现不起任何作用。而且由于编译时忽略注释部分,所以注释内容不会增加最终产生的可执行程序的大小。适当地使用注释,能够提高程序的可读性。在C++中,有两种给出注释的方法:一种是延用C语言方法,使用"/*"和"*/"括起注释文字。另一种方法是使用"//",从"//"开始,直到它所在行的行尾,所有字符都被作为注释处理。 2-8 什么叫做表达式?x = 5 + 7是一个表达式吗?它的值是多少? 解: 任何一个用于计算值的公式都可称为表达式。x = 5 + 7是一个表达式,它的值为12。 2-9 下列表达式的值是多少? 1. 201 / 4 2. 201 % 4 3. 201 / 4.0 解: 1. 50 2. 1 3. 50.25 2-10 执行完下列语句后,a、b、c三个变量的值为多少? a = 30; b = a++; c = ++a; 解: a:32 ; b:30 ; c:32; 2-11 在一个for循环中,可以初始化多个变量吗?如何实现? 解: 在for循环设置条件的第一个";"前,用,分隔不同的赋值表达式。 例如: for (x = 0, y = 10; x < 100; x++, y++) 2-12 执行完下列语句后,n的值为多少? int n; for (n = 0; n < 100; n++) 解: n的值为100 2-13 写一条for语句,计数条件为n从100到200,步长为2;然后用while和do…while语句完成同样的循环。 解: for循环: for (int n = 100; n <= 200; n += 2); while循环: int x = 100; while (n <= 200) n += 2; do…while循环: int n = 100; do { n += 2; } while(n y) x = y; else // y > x || y == x y = x; 2-17 修改下面这个程序中的错误,改正后它的运行结果是什么? #include void main() int i int j; i = 10; /* 给i赋值 j = 20; /* 给j赋值 */ cout << "i + j = << i + j; /* 输出结果 */ return 0; } 解: 改正: #include int main() { int i; int j; i = 10; // 给i赋值 j = 20; /* 给j赋值 */ cout << "i + j = " << i + j; /* 输出结果 */ return 0; } 程序运行输出: i + j = 30 2-18 编写一个程序,运行时提示输入一个数字,再把这个数字显示出来。 解: 源程序: #include int main() { int i; cout <> i; cout << "您输入一个数字是" << i << endl; return 0; } 程序运行输出: 请输入一个数字:5 您输入一个数字是5 2-19 C++有哪几种数据类型?简述其值域。编程显示你使用的计算机中的各种数据类型的字节数。 解: 源程序: #include int main() { cout << "The size of an int is:\t\t" << sizeof(int) << " bytes.\n"; cout << "The size of a short int is:\t" << sizeof(short) << " bytes.\n"; cout << "The size of a long int is:\t" << sizeof(long) << " bytes.\n"; cout << "The size of a char is:\t\t" << sizeof(char) << " bytes.\n"; cout << "The size of a float is:\t\t" << sizeof(float) << " bytes.\n"; cout << "The size of a double is:\t" << sizeof(double) << " bytes.\n"; return 0; } 程序运行输出: The size of an int is: 4 bytes. The size of a short int is: 2 bytes. The size of a long int is: 4 bytes. The size of a char is: 1 bytes. The size of a float is: 4 bytes. The size of a double is: 8 bytes. 2-20 打印ASCII码为32~127的字符。 解: #include int main() { for (int i = 32; i<128; i++) cout << (char) i; return 0; } 程序运行输出: !"#$%G'()*+,./0123456789:;?@ABCDEFGHIJKLMNOP_QRSTUVWXYZ[\]^'abcdefghijklmnopqrstuvwxyz~s 2-21 运行下面的程序,观察其输出,与你的设想是否相同? #include int main() { unsigned int x; unsigned int y = 100; unsigned int z = 50; x= y - z; cout << "Difference is: " << x; x = z - y; cout << "\nNow difference is: " << x <<endl; return 0; } 解: 程序运行输出: Difference is: 50 Now difference is: 4294967246 注意,第二行的输出并非 -50,注意x、y、z的数据类型。 2-22 运行下面的程序,观察其输出,体会i++与++i的差别。 #include int main() { int myAge = 39; // initialize two integers int yourAge = 39; cout << "I am: " << myAge << " years old.\n"; cout << "You are: " << yourAge << " years old\n"; myAge++; // postfix increment ++yourAge; // prefix increment cout << "One year passes...\n"; cout << "I am: " << myAge << " years old.\n"; cout << "You are: " << yourAge << " years old\n"; cout << "Another year passes\n"; cout << "I am: " << myAge++ << " years old.\n"; cout << "You are: " << ++yourAge << " years old\n"; cout << "Let's print it again.\n"; cout << "I am: " << myAge << " years old.\n"; cout << "You are: " << yourAge << " years old\n"; return 0; } 解: 程序运行输出: I am 39 years old You are 39 years old One year passes I am 40 years old You are 40 years old Another year passes I am 40 years old You are 41 years old Let's print it again I am 41 years old You are 41 years old 2-23 什么叫常量?什么叫变量? 解: 所谓常量是指在程序运行的整个过程中其值始终不可改变的量,除了用文字表示常量外,也可以为常量命名,这就是符号常量;在程序的执行过程中其值可以变化的量称为变量,变量是需要用名字来标识的。 2-24 变量有哪几种存储类型? 解: 变量有以下几种存储类型: auto存储类型:采用堆栈方式分配内存空间,属于一时性存储,其存储空间可以被若干变量多次覆盖使用; register存储类型:存放在通用寄存器中; extern存储类型:在所有函数和程序段中都可引用; static存储类型:在内存中是以固定地址存放的,在整个程序运行期间都有效。 2-25 写出下列表达式的值: 1. 2 < 3 && 6 < 9 2. ! ( 4 5) || (6 > 2 解: 1. 1 2. -1 3. 0 4. 0 2-28 编写一个完整的程序,实现功能:向用户提问"现在正在下雨吗?",提示用户输入Y或N。若输入为Y,显示"现在正在下雨。"; 若输入为N,显示"现在没有下雨。";否则继续提问"现在正在下雨吗?" 解: 源程序: #include #include void main() { char flag; while(1) { cout <> flag; if ( toupper(flag) == 'Y') { cout << "现在正在下雨。"; break; } if ( toupper(flag) == 'N') { cout << "现在没有下雨。"; break; } } } 程序运行输出: 现在正在下雨吗?(Yes or No):x 现在正在下雨吗?(Yes or No):l 现在正在下雨吗?(Yes or No):q 现在正在下雨吗?(Yes or No):n 现在没有下雨。 或: 现在正在下雨吗?(Yes or No):y 现在正在下雨。 2-29 编写一个完整的程序,运行时向用户提问"你考试考了多少分?(0~100)",接收输入后判断其等级,显示出来。规则如下: 解: #include void main() { int i,score; cout <> score; if (score>100 || score<0) cout << "分数值必须在0到100之间!"; else { i = score/10; switch (i) { case 10: case 9: cout << "你的成绩为优!"; break; case 8: cout << "你的成绩为良!"; break; case 7: case 6: cout << "你的成绩为中!"; break; default: cout << "你的成绩为差!"; } } } 程序运行输出: 你考试考了多少分?(0~100):85 你的成绩为良! 2-30 (1)实现一个简单的菜单程序,运行时显示"Menu: A(dd) D(elete) S(ort) Q(uit), Select one:"提示用户输入,A表示增加,D表示删除,S表示排序,Q表示退出,输入为A、D、S时分别提示"数据已经增加、删除、排序。"输入为Q时程序结束。要求使用if … else语句进行判断,用break、continue控制程序流程。 解: #include #include void main() { char choice,c; while(1) { cout <> c; choice = toupper(c); if (choice == 'A') { cout << "数据已经增加. " << endl; continue; } else if (choice == 'D') { cout << "数据已经删除. " << endl; continue; } else if (choice == 'S') { cout << "数据已经排序. " << endl; continue; } else if (choice == 'Q') break; } } 程序运行输出: Menu: A(dd) D(elete) S(ort) Q(uit), Select one:a 数据已经增加. Menu: A(dd) D(elete) S(ort) Q(uit), Select one:d 数据已经删除. Menu: A(dd) D(elete) S(ort) Q(uit), Select one:s 数据已经排序. Menu: A(dd) D(elete) S(ort) Q(uit), Select one:q (2)实现一个简单的菜单程序,运行时显示"Menu: A(dd) D(elete) S(ort) Q(uit), Select one:"提示用户输入,A表示增加,D表示删除,S表示排序,Q表示退出,输入为A、D、S时分别提示"数据已经增加、删除、排序。"输入为Q时程序结束。要求使用Switch语句。 解: 源程序: #include #include void main() { char choice; while(1) { cout <> choice; switch(toupper(choice)) { case 'A': cout << "数据已经增加. " << endl; break; case 'D': cout << "数据已经删除. " << endl; break; case 'S': cout << "数据已经排序. " << endl; break; case 'Q': exit(0); break; default: ; } } } 程序运行输出: Menu: A(dd) D(elete) S(ort) Q(uit), Select one:a 数据已经增加. Menu: A(dd) D(elete) S(ort) Q(uit), Select one:d 数据已经删除. Menu: A(dd) D(elete) S(ort) Q(uit), Select one:s 数据已经排序. Menu: A(dd) D(elete) S(ort) Q(uit), Select one:q 2-31 用穷举法找出1~100间的质数,显示出来。分别使用while,do-while,for循环语句实现。 解: 源程序: 使用while循环语句: #include #include void main() { int i,j,k,flag; i = 2; while(i <= 100) { flag = 1; k = sqrt(i); j = 2; while (j <= k) { if(i%j == 0) { flag = 0; break; } j++; } if (flag) cout << i << "是质数." << endl; i++; } } 使用do…while循环语句: #include #include void main() { int i,j,k,flag; i = 2; do{ flag = 1; k = sqrt(i); j = 2; do{ if(i%j == 0) { flag = 0; break; } j++; }while (j <= k); if (flag) cout << i << "是质数." << endl; i++; }while(i <= 100); } 使用for循环语句: #include #include void main() { int i,j,k,flag; for(i = 2; i <= 100; i++) { flag = 1; k = sqrt(i); for (j = 2; j <= k; j++) { if(i%j == 0) { flag = 0; break; } } if (flag) cout << i << "是质数." << endl; } } 程序运行输出: 2是质数. 3是质数. 5是质数. 7是质数. 11是质数. 13是质数. 17是质数. 19是质数. 23是质数. 29是质数. 31是质数. 37是质数. 41是质数. 43是质数. 47是质数. 53是质数. 59是质数. 61是质数. 67是质数. 71是质数. 73是质数. 79是质数. 83是质数. 89是质数. 97是质数. 2-32 比较Break语句与Continue语句的不同用法。 解: Break使程序从循环体和switch语句内跳出,继续执行逻辑上的下一条语句,不能用在别处; continue 语句结束本次循环,接着开始判断决定是否继续执行下一次循环; 2-33 定义一个表示时间的结构体,可以精确表示年、月、日、小时、分、秒;提示用户输入年、月、日、小时、分、秒的值,然后完整地显示出来。 解: 源程序见"实验指导"部分实验二 2-34 在程序中定义一个整型变量,赋以1~100的值,要求用户猜这个数,比较两个数的大小,把结果提示给用户,直到猜对为止。分别使用while、do…while语句实现循环。 解: //使用while语句 #include void main() { int n = 18; int m = 0; while(m != n) { cout <> m; if (n > m) cout << "你猜的值太小了!" << endl; else if (n < m) cout << "你猜的值太大了!" << endl; else cout << "你猜对了!" << endl; } } //使用do…while语句 #include void main() { int n = 18; int m = 0; do{ cout <> m; if (n > m) cout << "你猜的值太小了!" << endl; else if (n < m) cout << "你猜的值太大了!" << endl; else cout << "你猜对了!" << endl; }while(n != m); } 程序运行输出: 请猜这个数的值为多少?(0~~100):50 你猜的值太大了! 请猜这个数的值为多少?(0~~100):25 你猜的值太大了! 请猜这个数的值为多少?(0~~100):10 你猜的值太小了! 请猜这个数的值为多少?(0~~100):15 你猜的值太小了! 请猜这个数的值为多少?(0~~100):18 你猜对了! 2-35 定义枚举类型weekday,包括Sunday到Saturday七个元素在程序中定义weekday类型的变量,对其赋值,定义整型变量,看看能否对其赋weekday类型的值。 解: #include enum weekday { Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday }; void main() { int i; weekday d = Thursday; cout << "d = " << d << endl; i = d; cout << "i = " << i << endl; d = (weekday)6; cout << "d = " << d << endl; d = weekday( 4 ); cout << "d = " << d << endl; } 程序运行输出: d = 4 i = 4 d = 6 d = 4 2-36口袋中有红、黄、蓝、白、黑五种颜色的球若干个,每次从口袋中取出三个不同颜色的球,问有多少种取法。 解: #include using namespace std; int main() { enum color{red,yellow,blue,white,black}; enum color pri; int n,loop,i,j,k; char c; n=0; for(i=red;i<=black;i++) for(j=red;j<=black;j++) if(i!=j) { for(k=red;k<black;k++) if((k!=i)&&(k!=j)) { n=n+1; cout.width(4); cout<<n; for(loop=1;loop<=3;loop++) { switch(loop) { case 1: pri=(enum color)i; break; case 2: pri=(enum color)j; break; case 3: pri=(enum color)k; break; default: break; } switch(pri) { case red:cout<<"red";break; case yellow:cout<<"yellow";break; case blue:cout<<"blue";break; case white:cout<<"white";break; case black:cout<<"black";break; default: break; } } cout<<endl; } } cout<<"total:"<<n<<endl; } 2-37输出九九算表 #include #include using namespace std; int main() { int i,j; for(i=1;i<5;i++) cout<<setw(4)<<i; cout<<endl; cout<<endl; for(i=1;i<5;i++) { for(j=1;j<5;j++) cout<<setw(4)<<(i*j); cout<<endl; } } 第三章 函数 3-1 C++中的函数是什么?什么叫主调函数,什么叫被调函数,二者之间有什么关系?如何调用一个函数? 解: 一个较为复杂的系统往往需要划分为若干子系统,高级语言中的子程序就是用来实现这种模块划分的。C和C++语言中的子程序就体现为函数。调用其它函数的函数被称为主调函数,被其它函数调用的函数称为被调函数。一个函数很可能既调用别的函数又被另外的函数调用,这样它可能在某一个调用与被调用关系中充当主调函数,而在另一个调用与被调用关系中充当被调函数。 调用函数之前先要声明函数原型。按如下形式声明: 类型标识符 被调函数名 (含类型说明的形参表); 声明了函数原型之后,便可以按如下形式调用子函数: 函数名(实参列表) 3-2 观察下面程序的运行输出,与你设想的有何不同?仔细体会引用的用法。 源程序: #include int main() { int intOne; int &rSomeRef; = intOne; intOne = 5; cout << "intOne:\t\t" << intOne << endl; cout << "rSomeRef:\t" << rSomeRef << endl; int intTwo = 8; rSomeRef = intTwo; // not what you think! cout << "\nintOne:\t\t" << intOne << endl; cout << "intTwo:\t\t" << intTwo << endl; cout << "rSomeRef:\t" << rSomeRef << endl; return 0; } 程序运行输出: intOne: 5 rSomeRef: 5 intOne: 8 intTwo: 8 rSomeRef: 8 3-3 比较值调用和引用调用的相同点与不同点。 解: 值调用是指当发生函数调用时,给形参分配内存空间,并用实参来初始化形参(直接将实参的值传递给形参)。这一过程是参数值的单向传递过程,一旦形参获得了值便与实参脱离关系,此后无论形参发生了怎样的改变,都不会影响到实参。 引用调用将引用作为形参,在执行主调函数中的调用语句时,系统自动用实参来初始化形参。这样形参就成为实参的一个别名,对形参的任何操作也就直接作用于实参。 3-4 什么叫内联函数?它有哪些特点? 解: 定义时使用关键字 inline的函数叫做内联函数; 编译器在编译时在调用处用函数体进行替换,节省了参数传递、控制转移等开销; 内联函数体内不能有循环语句和switch语句; 内联函数的定义必须出现在内联函数第一次被调用之前; 对内联函数不能进行异常接口声明; 3-5 函数原型中的参数名与函数定义中的参数名以及函数调用中的参数名必须一致吗? 解: 不必一致,所有的参数是根据位置和类型而不是名字来区分的。 3-6 重载函数时通过什么来区分? 解: 重载的函数的函数名是相同的,但它们的参数的个数和数据类型不同,编译器根据实参和形参的类型及个数的最佳匹配,自动确定调用哪一个函数。 3-7 编写函数,参数为两个unsigned short int型数,返回值为第一个参数除以第二个参数的结果,数据类型为short int;如果第二个参数为0,则返回值为-1。在主程序中实现输入输出。 解: 源程序: #include short int Divider(unsigned short int a, unsigned short int b) { if (b == 0) return -1; else return a/b; } typedef unsigned short int USHORT; typedef unsigned long int ULONG; int main() { USHORT one, two; short int answer; cout <> one; cout <> two; answer = Divider(one, two); if (answer > -1) cout << "Answer: " << answer; else cout << "Error, can't divide by zero!"; return 0; } 程序运行输出: Enter two numbers. Number one:8 Number two:2 Answer: 4 3-8 编写函数把华氏温度转换为摄氏温度,公式为:C = (F - 32) * 5/9; 在主程序中提示用户输入一个华氏温度,转化后输出相应的摄氏温度。 解: 源程序见"实验指导"部分实验三 3-9 编写函数判断一个数是否是质数,在主程序中实现输入、输出。 解: #include #include int prime(int i); //判一个数是否是质数的函数 void main() { int i; cout <> i; if (prime(i)) cout << i << "是质数." << endl; else cout << i << "不是质数." << endl; } int prime(int i) { int j,k,flag; flag = 1; k = sqrt(i); for (j = 2; j <= k; j++) { if(i%j == 0) { flag = 0; break; } } if (flag) return 1; else return 0; } 程序运行输出: 请输入一个整数:1151 1151是质数. 3-10 编写函数求两个整数的最大公约数和最小公倍数。 解: 源程序: #include #include int fn1(int i,int j); //求最大公约数的函数 void main() { int i,j,x,y; cout <> i ; cout <> j ; x = fn1(i,j); y = i * j / x; cout << i << "和" << j << "的最大公约数是:" << x << endl; cout << i << "和" << j << "的最小公倍数是:" << y << endl; } int fn1(int i, int j) { int temp; if (i < j) { temp = i; i = j; j = i; } while(j != 0) { temp = i % j; i = j; j = temp; } return i; } 程序运行输出: 请输入一个正整数:120 请输入另一个正整数:72 120和72的最大公约数是:24 120和72的最小公倍数是:360 3-11 什么叫作嵌套调用?什么叫作递归调用? 解: 函数允许嵌套调用,如果函数1调用了函数2,函数2再调用函数3,便形成了函数的嵌套调用。 函数可以直接或间接地调用自身,称为递归调用。 3-12 在主程序中提示输入整数n,编写函数用递归的方法求1 + 2 + … + n的值。 解: #include #include int fn1(int i); void main() { int i; cout <> i ; cout << "从1累加到" <<i << "的和为:" << fn1(i) << endl; } int fn1(int i) { if (i == 1) return 1; else return i + fn1(i -1); } 程序运行输出: 请输入一个正整数:100 从1累加到100的和为:5050 3-13 编写递归函数GetPower(int x, int y)计算x的y次幂, 在主程序中实现输入输出。 解: 源程序: #include long GetPower(int x, int y); int main() { int number, power; long answer; cout <> number; cout <> power; answer = GetPower(number,power); cout << number << " to the " << power << "th power is " <<answer <2; fib(1) = fib(2) = 1;观察递归调用的过程。 解: 源程序见"实验指导"部分实验三 3-15 用递归的方法编写函数求n阶勒让德多项式的值,在主程序中实现输入、输出; 解: #include float p(int n, int x); void main() { int n,x; cout <> n; cout <> x; cout << "n = " << n << endl; cout << "x = " << x << endl; cout << "P" << n << "(" << x << ") = " << p(n,x) << endl; } float p(int n, int x) { if (n == 0) return 1; else if (n == 1) return x; else return ((2*n-1)*x*p(n-1,x) - (n-1)*p(n-2,x)) /n ; } 程序运行输出: 请输入正整数n:1 请输入正整数x:2 n = 1 x = 2 P1(2) = 2 请输入正整数n:3 请输入正整数x:4 n = 3 x = 4 P3(4) = 154 第 四 章 类 4-1 解释public和private的作用,公有类型成员与私有类型成员有些什么区别? 解: 公有类型成员用public关键字声明,公有类型定义了类的外部接口;私有类型的成员用private关键字声明,只允许本类的函数成员来访问,而类外部的任何访问都是非法的,这样,私有的成员就整个隐蔽在类中,在类的外部根本就无法看到,实现了访问权限的有效控制。 4-2 protected关键字有何作用? 解: protected用来声明保护类型的成员,保护类型的性质和私有类型的性质相似,其差别在于继承和派生时派生类的成员函数可以访问基类的保护成员。 4-3 构造函数和析构函数有什么作用? 解: 构造函数的作用就是在对象被创建时利用特定的值构造对象,将对象初始化为一个特定的状态,使此对象具有区别于彼对象的特征,完成的就是是一个从一般到具体的过程,构造函数在对象创建的时候由系统自动调用。 析构函数与构造函数的作用几乎正好相反,它是用来完成对象被删除前的一些清理工作,也就是专门作扫尾工作的。一般情况下,析构函数是在对象的生存期即将结束的时刻由系统自动调用的,它的调用完成之后,对象也就消失了,相应的内存空间也被释放。 4-4 数据成员可以为公有的吗?成员函数可以为私有的吗? 解: 可以,二者都是合法的。数据成员和成员函数都可以为公有或私有的。但数据成员最好定义为私有的。 4-5 已知class A中有数据成员int a,如果定义了A的两个对象A1、A2,它们各自的数据成员a的值可以不同吗? 解: 可以,类的每一个对象都有自己的数据成员。 4-6 什么叫做拷贝构造函数?拷贝构造函数何时被调用? 解: 拷贝构造函数是一种特殊的构造函数,具有一般构造函数的所有特性,其形参是本类的对象的引用,其作用是使用一个已经存在的对象,去初始化一个新的同类的对象。在以下三种情况下会被调用:在当用类的一个对象去初始化该类的另一个对象时;如果函数的形参是类对象,调用函数进行形参和实参结合时;如果函数的返回值是类对象,函数调用完成返回时; 4-7 拷贝构造函数与赋值运算符(=)有何不同? 解: 赋值运算符(=)作用于一个已存在的对象;而拷贝构造函数会创建一个新的对象。 4-8 定义一个Dog 类,包含的age、weight等属性,以及对这些属性操作的方法。实现并测试这个类。 解: 源程序: #include class Dog { public: Dog (int initialAge = 0, int initialWeight = 5); ~Dog(); int GetAge() { return itsAge;} // inline! void SetAge (int age) { itsAge = age;} // inline! int GetWeight() { return itsWeight;} // inline! void SetWeight (int weight) { itsAge = weight;} // inline! private: int itsAge, itsWeight; }; Dog::Dog(int initialAge, int initialWeight) { itsAge = initialAge; itsWeight = initialWeight; } Dog::~Dog() //destructor, takes no action { } int main() { Dog Jack(2,10); cout << "Jack is a Dog who is " ; cout << Jack.GetAge() << " years old and"; cout << Jack.GetWeight() << " pounds weight.\n"; Jack.SetAge(7); Jack.SetWeight(20); cout << "Now Jack is " ; cout << Jack.GetAge() << " years old and"; cout << Jack.GetWeight() << " pounds weight."; return 0; } 程序运行输出: Jack is a Dog who is 2 years old and 10 pounds weight. Now Jack is 7 years old 20 pounds weight. 4-9 设计并测试一个名为Rectangle的矩形类,其属性为矩形的左下角与右上角两个点的坐标,能计算矩形的面积。 解: 源程序: #include class Rectangle { public: Rectangle (int top, int left, int bottom, int right); ~Rectangle () {} int GetTop() const { return itsTop; } int GetLeft() const { return itsLeft; } int GetBottom() const { return itsBottom; } int GetRight() const { return itsRight; } void SetTop(int top) { itsTop = top; } void SetLeft (int left) { itsLeft = left; } void SetBottom (int bottom) { itsBottom = bottom; } void SetRight (int right) { itsRight = right; } int GetArea() const; private: int itsTop; int itsLeft; int itsBottom; int itsRight; }; Rectangle::Rectangle(int top, int left, int bottom, int right) { itsTop = top; itsLeft = left; itsBottom = bottom; itsRight = right; } int Rectangle::GetArea() const { int Width = itsRight-itsLeft; int Height = itsTop - itsBottom; return (Width * Height); } int main() { Rectangle MyRectangle (100, 20, 50, 80 ); int Area = MyRectangle.GetArea(); cout << "Area: " << Area << "\n"; return 0; } 程序运行输出: Area: 3000 Upper Left X Coordinate: 20 4-10 设计一个用于人事管理的People(人员)类。考虑到通用性,这里只抽象出所有类型人员都具有的属性:number(编号)、sex(性别)、birthday(出生日期)、id(身份证号)等等。其中"出生日期"定义为一个"日期"类内嵌子对象。用成员函数实现对人员信息的录入和显示。要求包括:构造函数和析构函数、拷贝构造函数、内联成员函数、带缺省形参值的成员函数、聚集。 解: 本题用作实验四的选做题,因此不给出答案。 4-11 定义一个矩形类,有长、宽两个属性,有成员函数计算矩形的面积 解: #include class Rectangle { public: Rectangle(float len, float width) { Length = len; Width = width; } ~Rectangle(){}; float GetArea() { return Length * Width; } float GetLength() { return Length; } float GetWidth() { return Width; } private: float Length; float Width; }; void main() { float length, width; cout <> length; cout <> width; Rectangle r(length, width); cout << "长为" << length << "宽为" << width << "的矩形的面积为:" << r.GetArea () << endl; } 程序运行输出: 请输入矩形的长度:5 请输入矩形的宽度:4 长为5宽为4的矩形的面积为:20 4-12 定义一个"数据类型" datatype类,能处理包含字符型、整型、浮点型三种类型的数据,给出其构造函数。 解: #include class datatype{ enum{ character, integer, floating_point } vartype; union { char c; int i; float f; }; public: datatype(char ch) { vartype = character; c = ch; } datatype(int ii) { vartype = integer; i = ii; } datatype(float ff) { vartype = floating_point; f = ff; } void print(); }; void datatype::print() { switch (vartype) { case character: cout << "字符型: " << c << endl; break; case integer: cout << "整型: " << i << endl; break; case floating_point: cout << "浮点型: " << f << endl; break; } } void main() { datatype A('c'), B(12), C(1.44F); A.print(); B.print(); C.print(); } 程序运行输出: 字符型: c 整型: 12 浮点型: 1.44 4-13 定义一个Circle类,有数据成员半径Radius,成员函数GetArea(),计算圆的面积,构造一个Circle的对象进行测试。 解: #include class Circle { public: Circle(float radius){ Radius = radius;} ~Circle(){} float GetArea() { return 3.14 * Radius * Radius; } private: float Radius; }; void main() { float radius; cout <> radius; Circle p(radius); cout << "半径为" << radius << "的圆的面积为:" << p.GetArea () << endl; } 程序运行输出: 请输入圆的半径:5 半径为5的圆的面积为:78.5 4-14 定义一个tree类,有成员ages,成员函数grow(int years)对ages加上years,age()显示tree对象的ages的值。 解: #include class Tree { int ages; public: Tree(int n=0); ~Tree(); void grow(int years); void age(); }; Tree::Tree(int n) { ages = n; } Tree::~Tree() { age(); } void Tree::grow(int years) { ages += years; } void Tree::age() { cout << "这棵树的年龄为" << ages << endl; } void main() { Tree t(12); t.age(); t.grow(4); } 程序运行输出: 这棵树的年龄为12 这棵树的年龄为16 第 五 章 C++程序的基本结构 5-1 什么叫做作用域?有哪几种类型的作用域? 解: 作用域讨论的是标识符的有效范围,作用域是一个标识符在程序正文中有效的区域。C++的作用域分为函数原形作用域、块作用域(局部作用域)、类作用域和文件作用域. 5-2 什么叫做可见性?可见性的一般规则是什么? 解: 可见性是标识符是否可以引用的问题; 可见性的一般规则是:标识符要声明在前,引用在后,在同一作用域中,不能声明同名的标识符。对于在不同的作用域声明的标识符,遵循的原则是:若有两个或多个具有包含关系的作用域,外层声明的标识符如果在内层没有声明同名标识符时仍可见,如果内层声明了同名标识符则外层标识符不可见。 5-3 下面的程序的运行结果是什么,实际运行一下,看看与你的设想有何不同。 #include void myFunction(); int x = 5, y = 7; int main() { cout << "x from main: " << x << "\n"; cout << "y from main: " << y << "\n\n"; myFunction(); cout << "Back from myFunction!\n\n"; cout << "x from main: " << x << "\n"; cout << "y from main: " << y << "\n"; return 0; } void myFunction() { int y = 10; cout << "x from myFunction: " << x << "\n"; cout << "y from myFunction: " << y << "\n\n"; } 解: 程序运行输出: x from main: 5 y from main: 7 x from myFunction: 5 y from myFunction: 10 Back from myFunction! x from main: 5 y from main: 7 5-4 假设有两个无关系的类Engine和Fuel,使用时,怎样允许Fuel成员访问Engine中的私有和保护的成员? 解: 源程序: class fuel; class engine { friend class fuel; private; int powerlevel; public; engine(){ powerLevel = 0;} void engine_fn(fuel &f); }; class fuel { friend class engine; private; int fuelLevel; public: fuel(){ fuelLevel = 0;} void fuel_fn( engine &e); }; 5-5 什么叫做静态数据成员?它有何特点? 解: 类的静态数据成员是类的数据成员的一种特例,采用static关键字来声明。对于类的普通数据成员,每一个类的对象都拥有一个拷贝,就是说每个对象的同名数据成员可以分别存储不同的数值,这也是保证对象拥有自身区别于其它对象的特征的需要,但是静态数据成员,每个类只要一个拷贝,由所有该类的对象共同维护和使用,这个共同维护、使用也就实现了同一类的不同对象之间的数据共享。 5-6 什么叫做静态函数成员?它有何特点? 解: 使用static关键字声明的函数成员是静态的,静态函数成员属于整个类,同一个类的所有对象共同维护,为这些对象所共享。静态函数成员具有以下两个方面的好处,一是由于静态成员函数只能直接访问同一个类的静态数据成员,可以保证不会对该类的其余数据成员造成负面影响;二是同一个类只维护一个静态函数成员的拷贝,节约了系统的开销,提高程序的运行效率。 5-7 定义一个Cat类,拥有静态数据成员HowManyCats,记录Cat的个体数目;静态成员函数GetHowMany(),存取HowManyCats。设计程序测试这个类,体会静态数据成员和静态成员函数的用法。 解: 源程序: #include class Cat { public: Cat(int age):itsAge(age){HowManyCats++; } virtual ~Cat() { HowManyCats--; } virtual int GetAge() { return itsAge; } virtual void SetAge(int age) { itsAge = age; } static int GetHowMany() { return HowManyCats; } private: int itsAge; static int HowManyCats; }; int Cat::HowManyCats = 0; void TelepathicFunction(); int main() { const int MaxCats = 5; Cat *CatHouse[MaxCats]; int i; for (i = 0; i<MaxCats; i++) { CatHouse[i] = new Cat(i); TelepathicFunction(); } for ( i = 0; i<MaxCats; i++) { delete CatHouse[i]; TelepathicFunction(); } return 0; } void TelepathicFunction() { cout << "There are " << Cat::GetHowMany() << " cats alive!\n"; } 程序运行输出: There are 1 cats alive! There are 2 cats alive! There are 3 cats alive! There are 4 cats alive! There are 5 cats alive! There are 4 cats alive! There are 3 cats alive! There are 2 cats alive! There are 1 cats alive! There are 0 cats alive! 5-8 什么叫做友元函数?什么叫做友元类? 解: 友元函数是使用friend关键字声明的函数,它可以访问相应类的保护成员和私有成员。友元类是使用friend关键字声明的类,它的所有成员函数都是相应类的友元函数。 5-9 如果类A是类B的友元,类B是类C的友元,类D是类A的派生类,那么类B是类A的友元吗?类C是类A的友元吗?类D是类B的友元吗? 解: 类B不是类A的友元,友元关系不具有交换性; 类C不是类A的友元,友元关系不具有传递性; 类D不是类B的友元,友元关系不能被继承。 5-10 静态成员变量可以为私有的吗?声明一个私有的静态整型成员变量。 解: 可以,例如: private: static int a; 5-11 在一个文件中定义一个全局变量n,主函数main(),在另一个文件中定义函数fn1(),在main()中对n赋值,再调用fn1(),在fn1()中也对n赋值,显示n最后的值。 解: #include #include "fn1.h" int n; void main() { n = 20; fn1(); cout << "n的值为" <<n; } // fn1.h文件 extern int n; void fn1() { n=30; } 程序运行输出: n的值为30 5-12 在函数fn1()中定义一个静态变量n,fn1()中对n的值加1,在主函数中,调用fn1()十次,显示n的值。 解: #include void fn1() { static int n = 0; n++; cout << "n的值为" << n <<endl; } void main() { for(int i = 0; i i =+10; } void Y::g(X* x) { x->i ++; } class Z { public: void f(X* x) { x->i += 5; } }; #endif // MY_X_Y_Z_H 程序运行输出:无 5-14 定义Boat与Car两个类,二者都有weight属性,定义二者的一个友元函数totalWeight(),计算二者的重量和。 解: 源程序: #include class Boat; class Car { private: int weight; public: Car(int j){weight = j;} friend int totalWeight(Car &aCar;, Boat &aBoat;); }; class Boat { private: int weight; public: Boat(int j){weight = j;} friend int totalWeight(Car &aCar;, Boat &aBoat;); }; int totalWeight(Car &aCar;, Boat &aBoat;) { return aCar.weight + aBoat.weight; } void main() { Car c1(4); Boat b1(5); cout << totalWeight(c1, b1) << endl; } 程序运行输出: 9 第 六 章 数组、指针与字符串 6-1 数组A[10][5][15]一共有多少个元素? 解: 10×5×15 = 750 个元素 6-2 在数组A[20]中第一个元素和最后一个元素是哪一个? 解: 第一个元素是A[0],最后一个元素是A[19]。 6-3 用一条语句定义一个有五个元素的整型数组,并依次赋予1~5的初值。 解: 源程序: int IntegerArray[5] = { 1, 2, 3, 4, 5 }; 或:int IntegerArray[] = { 1, 2, 3, 4, 5 }; 6-4 已知有一个数组名叫oneArray,用一条语句求出其元素的个数。 解: 源程序: nArrayLength = sizeof(oneArray) / sizeof(oneArray[0]); 6-5 用一条语句定义一个有5×3个元素的二维整型数组,并依次赋予1~15的初值。 解: 源程序: int theArray[5][3] = { 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15 }; 或:int theArray[5][3] = { {1,2,3}, {4,5,6}, {7,8,9}, {10,11,12},{13,14,15} }; 6-6 运算符*和&的作用是什么? 解: *称为指针运算符,是一个一元操作符,表示指针所指向的对象的值;&称为取地址运算符,也是一个一元操作符,是用来得到一个对象的地址。 6-7 什么叫做指针指针中储存的地址和这个地址中的值有何区别? 解: 指针是一种数据类型,具有指针类型的变量称为指针变量。指针变量存放的是另外一个对象的地址,这个地址中的值就是另一个对象的内容。 6-8 定义一个整型指针,用new语句为其分配包含10个整型元素的地址空间。 解: 源程序: int *pInteger = new int[10]; 6-9 在字符串”Hello,world!”中结束符是什么? 解: 是NULL字符。 6-10 定义一个有五个元素的整型数组,在程序中提示用户输入元素值,最后再在屏幕上显示出来。 解: 源程序: #include int main() { int myArray[5]; int i; for ( i=0; i<5; i++) { cout << "Value for myArray[" << i <> myArray[i]; } for (i = 0; i<5; i++) cout << i << ": " << myArray[i] << "\n"; return 0; } 程序运行输出: Value for myArray[0]: 2 Value for myArray[1]: 5 Value for myArray[2]: 7 Value for myArray[3]: 8 Value for myArray[4]: 3 0: 2 1: 5 2: 7 3: 8 4: 3 6-11 引用和指针有何区别?何时只能使用指针而不能使用引用? 解: 引用是一个别名,不能为NULL值,不能被重新分配;指针是一个存放地址的变量。当需要对变量重新赋以另外的地址或赋值为NULL时只能使用指针。 6-12 声明下列指针:float类型变量的指针pFloat,char类型的指针pString和struct customer型的指针prec。 解: float *pfloat; char *pString; struct customer *prec; 6-13 给定float类型的指针fp,写出显示fp所指向的值的输出流语句。 解: cout << "Value == " << *fp; 6-14 程序中定义一个double类型变量的指针。分别显示指针占了多少字节和指针所指的变量占了多少字节。 解: double *counter; cout << "\nSize of pointer == "sizeof(counter); cout << '\nSize of addressed value == "<<sizeof(*counter); 6-15 const int * p1 和 int * const p2的区别是什么? 解: const int * p1 声明了一个指向整型常量的指针p1,因此不能通过指针p1来改变它所指向的整型值;int * const p2声明了一个指针型常量,用于存放整型变量的地址,这个指针一旦初始化后,就不能被重新赋值了。 6-16 定义一个整型变量a,一个整型指针p,一个引用r,通过p把a的值改为10,通过r把a的值改为5 解: void main() { int a; int *p = &a; int &r = a; *p = 10; r = 5; } 6-17 下列程序有何问题,请仔细体会使用指针时应避免出现这个的问题。 #include int main() { int *p; *pInt = 9; cout << "The value at p: " << *p; return 0; } 解: 指针p没有初始化,也就是没有指向某个确定的内存单元,它指向内存中的一个随机地址,给这个随机地址赋值是非常危险的。 6-18 下列程序有何问题,请改正;仔细体会使用指针时应避免出现的这个问题。 #include int Fn1(); int main() { int a = Fn1(); cout << "the value of a is: " << a; return 0; } int Fn1() { int * p = new int (5); return *p; } 解: 此程序中给*p分配的内存没有被释放掉。 改正: #include int* Fn1(); int main() { int *a = Fn1(); cout << "the value of a is: " << *a; delete a; return 0; } int* Fn1() { int * p = new int (5); return p; } 6-19 声明一个参数为整型,返回值为长整型的函数指针;声明类A的一个成员函数指针,其参数为整型,返回值长整型。 解: long (* p_fn1)(int); long ( A::*p_fn2)(int); 6-20 实现一个名为SimpleCircle的简单圆类,其数据成员int *itsRadius为一个指向其半径值的指针,设计对数据成员的各种操作,给出这个类的完整实现并测试这个类。 解: 源程序: #include class SimpleCircle { public: SimpleCircle(); SimpleCircle(int); SimpleCircle(const SimpleCircle &); ~SimpleCircle() {} void SetRadius(int); int GetRadius()const; private: int *itsRadius; }; SimpleCircle::SimpleCircle() { itsRadius = new int(5); } SimpleCircle::SimpleCircle(int radius) { itsRadius = new int(radius); } SimpleCircle::SimpleCircle(const SimpleCircle & rhs) { int val = rhs.GetRadius(); itsRadius = new int(val); } int SimpleCircle::GetRadius() const { return *itsRadius; } int main() { SimpleCircle CircleOne, CircleTwo(9); cout << "CircleOne: " << CircleOne.GetRadius() << endl; cout << "CircleTwo: " << CircleTwo.GetRadius() << endl; return 0; }程序运行输出: CircleOne: 5 CircleTwo: 9 6-21 编写一个函数,统计一个英文句子中字母的个数,在主程序中实现输入、输出。 解: 源程序: #include #include int count(char *str) { int i,num=0; for (i=0; str[i]; i++) { if ( (str[i]>='a' && str[i]='A' && str[i]<='Z') ) num++; } return num; } void main() { char text[100]; cout << "输入一个英语句子:" << endl; gets(text); cout << "这个句子里有" << count(text) << "个字母。" << endl; } 程序运行输出: 输入一个英语句子: It is very interesting! 这个句子里有19个字母。 6-22 编写函数int index(char *s, char *t),返回字符串t 在字符串s中出现的最左边的位置,如果在s中没有与t匹配的子串,就返回-1。 解: 源程序: #include int index( char *s, char *t) { int i,j,k; for(i = 0; s[i] != '\0'; i++) { for(j = i, k = 0; t[k] != '\0' && s[j] == t[k]; j++, k++) ; if (t[k] =='\0') return i; } return -1; } void main() { int n; char str1[20],str2[20]; cout <> str1; cout <> str2; n = index(str1,str2); if (n > 0) cout << str2 << "在" << str1 << "中左起第" << n+1 << "个位置。"<<endl; else cout << str2 << "不在" << str1 << "中。" << endl; } 程序运行输出: 输入一个英语单词:abcdefgh 输入另一个英语单词:de de在abcdefghijk中左起第4个位置。 6-23 编写函数reverse(char *s)的倒序递归程序,使字符串s倒序。 解: 源程序: #include #include void reverse(char *s, char *t) { char c; if (s < t) { c = *s; *s = *t; *t = c; reverse(++s, --t); } } void reverse( char *s) { reverse(s, s + strlen(s) - 1); } void main() { char str1[20]; cout <> str1; cout << "原字符串为:" << str1 << endl; reverse(str1); cout << "倒序反转后为:" << str1 << endl; } 程序运行输出: 输入一个字符串:abcdefghijk 原字符串为:abcdefghijk 倒序反转后为:kjihgfedcba 6-24 设学生人数N=8,提示用户输入N个人的考试成绩,然后计算出平均成绩,显示出来。 解: 源程序: #include #include #define N 8 float grades[N]; //存放成绩的数组 void main() { int i; float total,average; //提示输入成绩 for(i = 0; i < N; i++ ) { cout << "Enter grade #" <<(i +1) <> grades[i]; } total = 0; for (i = 0; i < N; i++) total += grades[i]; average = total / N; cout << "\nAverage grade: " << average << endl; } 程序运行输出: Enter grade #1: 86 Enter grade #2: 98 Enter grade #3: 67 Enter grade #4: 80 Enter grade #5: 78 Enter grade #6: 95 Enter grade #7: 78 Enter grade #8: 56 Average grade: 79.75 6-25 设计一个字符串类MyString,具有构造函数、析构函数、拷贝构造函数,重载运算符+、=、+=、[],尽可能地完善它,使之能满足各种需要。(运算符重载功能为选做,参见第8章) 解: #include #include class MyString { public: MyString(); MyString(const char *const); MyString(const MyString &); ~MyString(); char & operator[](unsigned short offset); char operator[](unsigned short offset) const; MyString operator+(const MyString&); void operator+=(const MyString&); MyString & operator= (const MyString &); unsigned short GetLen()const { return itsLen; } const char * GetMyString() const { return itsMyString; } private: MyString (unsigned short); // private constructor char * itsMyString; unsigned short itsLen; }; MyString::MyString() { itsMyString = new char[1]; itsMyString[0] = '\0'; itsLen=0; } MyString::MyString(unsigned short len) { itsMyString = new char[len+1]; for (unsigned short i = 0; i<=len; i++) itsMyString[i] = '\0'; itsLen=len; } MyString::MyString(const char * const cMyString) { itsLen = strlen(cMyString); itsMyString = new char[itsLen+1]; for (unsigned short i = 0; i<itsLen; i++) itsMyString[i] = cMyString[i]; itsMyString[itsLen]='\0'; } MyString::MyString (const MyString & rhs) { itsLen=rhs.GetLen(); itsMyString = new char[itsLen+1]; for (unsigned short i = 0; i<itsLen;i++) itsMyString[i] = rhs[i]; itsMyString[itsLen] = '\0'; } MyString::~MyString () { delete [] itsMyString; itsLen = 0; } MyString& MyString::operator=(const MyString & rhs) { if (this == &rhs;) return *this; delete [] itsMyString; itsLen=rhs.GetLen(); itsMyString = new char[itsLen+1]; for (unsigned short i = 0; i itsLen) return itsMyString[itsLen-1]; else return itsMyString[offset]; } char MyString::operator[](unsigned short offset) const { if (offset > itsLen) return itsMyString[itsLen-1]; else return itsMyString[offset]; } MyString MyString::operator+(const MyString& rhs) { unsigned short totalLen = itsLen + rhs.GetLen(); MyString temp(totalLen); for (unsigned short i = 0; i<itsLen; i++) temp[i] = itsMyString[i]; for (unsigned short j = 0; j<rhs.GetLen(); j++, i++) temp[i] = rhs[j]; temp[totalLen]='\0'; return temp; } void MyString::operator+=(const MyString& rhs) { unsigned short rhsLen = rhs.GetLen(); unsigned short totalLen = itsLen + rhsLen; MyString temp(totalLen); for (unsigned short i = 0; i<itsLen; i++) temp[i] = itsMyString[i]; for (unsigned short j = 0; j<rhs.GetLen(); j++, i++) temp[i] = rhs[i-itsLen]; temp[totalLen]='\0'; *this = temp; } int main() { MyString s1("initial test"); cout << "S1:\t" << s1.GetMyString() << endl; char * temp = "Hello World"; s1 = temp; cout << "S1:\t" << s1.GetMyString() << endl; char tempTwo[20]; strcpy(tempTwo,"; nice to be here!"); s1 += tempTwo; cout << "tempTwo:\t" << tempTwo << endl; cout << "S1:\t" << s1.GetMyString() << endl; cout << "S1[4]:\t" << s1[4] << endl; s1[4]='x'; cout << "S1:\t" << s1.GetMyString() << endl; cout << "S1[999]:\t" << s1[999] << endl; MyString s2(" Another myString"); MyString s3; s3 = s1+s2; cout << "S3:\t" << s3.GetMyString() << endl; MyString s4; s4 = "Why does this work?"; cout << "S4:\t" << s4.GetMyString() << endl; return 0; } 程序运行输出: S1: initial test S1: Hello World tempTwo: ; nice to be here! S1: Hello World; nice to be here! S1[4]: o S1: Hellx World; nice to be here! S1[999]: ! S3: Hellx World; nice to be here! Another myString S4: Why does this work? 6-26 编写一个3×3矩阵转置的函数,在main()函数中输入数据。 解: #include void move (int matrix[3][3]) { int i, j, k; for(i=0; i<3; i++) for (j=0; j<i; j++) { k = matrix[i][j]; matrix[i][j] = matrix[j][i]; matrix[j][i] = k; } } void main() { int i, j; int data[3][3]; cout << "输入矩阵的元素" << endl; for(i=0; i<3; i++) for (j=0; j<3; j++) { cout << "第" << i+1 << "行第" << j+1 <> data[i][j]; } cout << "输入的矩阵的为:" << endl; for(i=0; i<3; i++) { for (j=0; j<3; j++) cout << data[i][j] << " "; cout << endl; } move(data); cout << "转置后的矩阵的为:" << endl; for(i=0; i<3; i++) { for (j=0; j<3; j++) cout << data[i][j] << " "; cout << endl; } } 程序运行输出: 输入矩阵的元素 第1行第1个元素为:1 第1行第2个元素为:2 第1行第3个元素为:3 第2行第1个元素为:4 第2行第2个元素为:5 第2行第3个元素为:6 第3行第1个元素为:7 第3行第2个元素为:8 第3行第3个元素为:9 输入的矩阵的为: 1 2 3 4 5 6 7 8 9 转置后的矩阵的为: 1 4 7 2 5 8 3 6 9 6-27 编写一个矩阵转置的函数,矩阵的维数在程序中由用户输入。 解: #include void move (int *matrix ,int n) { int i, j, k; for(i=0; i<n; i++) for (j=0; j<i; j++) { k = *(matrix + i*n + j); *(matrix + i*n + j) = *(matrix + j*n + i); *(matrix + j*n + i) = k; } } void main() { int n, i, j; int *p; cout <> n; p = new int[n*n]; cout << "输入矩阵的元素" << endl; for(i=0; i<n; i++) for (j=0; j<n; j++) { cout << "第" << i+1 << "行第" << j+1 <> p[i*n + j]; } cout << "输入的矩阵的为:" << endl; for(i=0; i<n; i++) { for (j=0; j<n; j++) cout << p[i*n + j] << " "; cout << endl; } move(p, n); cout << "转置后的矩阵的为:" << endl; for(i=0; i<n; i++) { for (j=0; j<n; j++) cout << p[i*n + j] << " "; cout << endl; } } 程序运行输出: 请输入矩阵的维数:3 输入矩阵的元素 第1行第1个元素为:1 第1行第2个元素为:2 第1行第3个元素为:3 第2行第1个元素为:4 第2行第2个元素为:5 第2行第3个元素为:6 第3行第1个元素为:7 第3行第2个元素为:8 第3行第3个元素为:9 输入的矩阵的为: 1 2 3 4 5 6 7 8 9 转置后的矩阵的为: 1 4 7 2 5 8 3 6 9 6-28 定义一个Employee类,其中包括表示姓名、街道地址、城市和邮编等属性,包括chage_name()和display()等函数;display()使用cout语句显示姓名、街道地址、城市和邮编等属性,函数change_name()改变对象的姓名属性,实现并测试这个类。 解: 源程序: #include #include class Employee { private: char name[30]; char street[30]; char city[18]; char zip[6]; public: Employee(char *n, char *str, char *ct, char *z); void change_name(char *n); void display(); }; Employee::Employee (char *n,char *str,char *ct, char *z) { strcpy(name, n); strcpy(street, str); strcpy(city, ct); strcpy(zip, z); } void Employee::change_name (char *n) { strcpy(name, n); } void Employee::display () { cout << name << " " << street << " "; cout << city << " "<< zip; } void main(void) { Employee e1("张三","平安大街3号", "北京", "100000"); e1.display(); cout << endl; e1.change_name("李四"); e1.display(); cout << endl; } 程序运行输出: 张三 平安大街3号 北京 100000 李四 平安大街3号 北京 100000 第 七 章 继承与派生 7-1 比较类的三种继承方式public公有继承、protected保护继承、private私有继承之间的差别。 解: 不同的继承方式,导致不同访问属性的基类成员在派生类中的访问属性也有所不同: 公有继承,使得基类public(公有)和protected(保护)成员的访问属性在派生类中不变,而基类private(私有)成员不可访问。 私有继承,使得基类public(公有)和protected(保护)成员都以private(私有)成员身份出现在派生类中,而基类private(私有)成员不可访问。 保护继承中,基类public(公有)和protected(保护)成员都以protected(保护)成员身份出现在派生类中,而基类private(私有)成员不可访问。 7-2 派生类构造函数执行的次序是怎样的? 解: 派生类构造函数执行的一般次序为:调用基类构造函数;调用成员对象的构造函数;派生类的构造函数体中的内容。 7-3 如果在派生类B已经重载了基类A的一个成员函数fn1(),没有重载成员函数fn2(),如何调用基类的成员函数fn1()、fn2()? 解: 调用方法为: A::fn1(); fn2(); 7-4 什么叫做虚基类?有何作用? 解: 当某类的部分或全部直接基类是从另一个基类派生而来,这些直接基类中,从上一级基类继承来的成员就拥有相同的名称,派生类的对象的这些同名成员在内存中同时拥有多个拷贝,我们可以使用作用域分辨符来唯一标识并分别访问它们。我们也可以将直接基类的共同基类设置为虚基类,这时从不同的路径继承过来的该类成员在内存中只拥有一个拷贝,这样就解决了同名成员的唯一标识问题。 虚基类的声明是在派生类的定义过程,其语法格式为: class 派生类名:virtual 继承方式 基类名 上述语句声明基类为派生类的虚基类,在多继承情况下,虚基类关键字的作用范围和继承方式关键字相同,只对紧跟其后的基类起作用。声明了虚基类之后,虚基类的成员在进一步派生过程中,和派生类一起维护一个内存数据拷贝。 7-5 定义一个Shape基类,在此基础上派生出Rectangle和Circle,二者都有GetArea()函数计算对象的面积。使用Rectangle类创建一个派生类Square。 解: 源程序: #include class Shape { public: Shape(){} ~Shape(){} virtual float GetArea() { return -1; } }; class Circle : public Shape { public: Circle(float radius):itsRadius(radius){} ~Circle(){} float GetArea() { return 3.14 * itsRadius * itsRadius; } private: float itsRadius; }; class Rectangle : public Shape { public: Rectangle(float len, float width): itsLength(len), itsWidth(width){}; ~Rectangle(){}; virtual float GetArea() { return itsLength * itsWidth; } virtual float GetLength() { return itsLength; } virtual float GetWidth() { return itsWidth; } private: float itsWidth; float itsLength; }; class Square : public Rectangle { public: Square(float len); ~Square(){} }; Square::Square(float len): Rectangle(len,len) { } void main() { Shape * sp; sp = new Circle(5); cout << "The area of the Circle is " <GetArea () << endl; delete sp; sp = new Rectangle(4,6); cout << "The area of the Recta
CruiseYoung提供的带有详细书签的电子书籍目录 http://blog.csdn.net/fksec/article/details/7888251 该资料是《Visual C++ 2010入门经典(第5版)》的源代码及课后练习答案 对应的书籍资料见: Visual C++ 2010入门经典(第5版) 基本信息 原书名: Ivor Horton's Beginning Visual C++ 2010 原出版社: Wrox 作者: (美)Ivor Horton 译者: 苏正泉 李文娟 出版社:清华大学出版社 ISBN:9787302239994 上架时间:2010-12-20 出版日期:2010 年12月 开本:16开 页码:1011 版次:5-1 编辑推荐   本书针对visual c++ 2010版本做了全面更新,介绍了最新开发环境,讲述了如何使用visual c++构建真实世界的应用程序。    采用了容易理解的讲授方法,并提供了详尽的示例,旨在帮助读者掌握编程技巧 内容简介   作者ivor horton采用了容易理解的讲授方法,并提供了详尽的示例,帮助读者迅速地成为一名优秀的c++编程人员。《visual c++ 2010入门经典(第5版)》针对visual c++ 2010版本进行了全面更新,介绍了最新的开发环境和如何使用visual c++构建现实世界中的应用程序。拥有本书,您就迈向了通往使用两种c++版本编写应用程序的成功之路,并成为一名优秀的c++编程人员。    主要内容    ·使用visual c++ 2010支持的两种c++语言技术讲述c++编程的基础知识    ·分享c++程序的错误查找技术,并介绍通用的调试原则讨论每一个windows应用程序的结构和基本元素    ·举例说明如何使用mfc开发本地windows应用程序    ·指导读者用c++和c++/cli设计和创建大量的windows应用程序    ·为帮助读者掌握编程技巧,提供了大量可运行的示例和练习 作译者   Ivor Horton是撰著Java、C和C++编程语言图书的杰出作家之一。大家一致认为,他的著作独具风格,无论是编程新手,还是经验丰富的编程人员,都很容易理解其内容。在个人实践中,Ivor Horton也是一名系统顾问。他从事程序设计教学工作已经超过了25年。   苏正泉,1995年毕业于解放军信息工程学院计算机及应用专业,高级工程师。在IT项目管理、软件开发、系统管理和网络管理方面都有非常丰富的实践经验。曾发表过多篇计算机专业论文,并翻译过多部计算机专业技术书籍。   李文娟,中国石油大学(华东)硕士,现供职于国家行政学院,工作后一直从事软件开发和软件项目管理工作,对计算机语言、计算机体系结构、操作系统都非常熟悉,尤其是精通C和C++编程技术. 目录 封面 -19 封底 -18 扉页 -17 版权 -16 前言 -15 目录 -10 第1章 使用Visual C++ 2010编程 1 1.1 .NET Framework 1 1.2 CLR 2 1.3 编写C++应用程序 3 1.4 学习Windows编程 4 1.4.1 学习C++ 4 1.4.2 C++标准 5 1.4.3 属性 5 1.4.4 控制台应用程序 5 1.4.5 Windows编程概念 6 1.5 集成开发环境简介 7 1.5.1 编辑器 8 1.5.2 编译器 8 1.5.3 链接器 8 1.5.4 库 8 1.6 使用IDE 8 1.6.1 工具栏选项 9 1.6.2 可停靠的工具栏 10 1.6.3 文档 11 1.6.4 项目和解决方案 11 1.6.5 设置Visual C++ 2010的选项 23 1.6.6 创建和执行Windows应用程序 23 1.6.7 创建Windows Forms应用程序 26 1.7 小结 27 1.8 本章主要内容 28 第2章 数据、变量和计算 29 2.1 C++程序结构 29 2.1.1 main()函数 36 2.1.2 程序语句 36 2.1.3 空白 38 2.1.4 语句块 38 2.1.5 自动生成的控制台程序 39 2.2 定义变量 40 2.2.1 命名变量 40 2.2.2 声明变量 41 2.2.3 变量的初始值 42 2.3 基本数据类型 42 2.3.1 整型变量 43 2.3.2 字符数据类型 44 2.3.3 整型修饰符 45 2.3.4 布尔类型 46 2.3.5 浮点类型 46 2.3.6 字面值 47 2.3.7 定义数据类型的同义词 48 2.3.8 具有特定值集的变量 49 2.4 基本的输入/输出操作 50 2.4.1 从键盘输入 50 2.4.2 到命令行的输出 50 2.4.3 格式化输出 51 2.4.4 转义序列 52 2.5 C++中的计算 54 2.5.1 赋值语句 54 2.5.2 算术运算 55 2.5.3 计算余数 59 2.5.4 修改变量 60 2.5.5 增量和减量运算符 60 2.5.6 计算的顺序 63 2.6 类型转换和类型强制转换 64 2.6.1 赋值语句中的类型转换 65 2.6.2 显式类型转换 65 2.6.3 老式的类型强制转换 66 2.7 AUTO关键字 66 2.8 查看类型 67 2.9 按位运算符 67 2.9.1 按位AND运算符 68 2.9.2 按位OR运算符 69 2.9.3 按位EOR运算符 71 2.9.4 按位NOT运算符 71 2.9.5 移位运算符 71 2.10 lvalue和rvalue 73 2.11 了解存储时间和作用域 74 2.11.1 自动变量 74 2.11.2 决定变量声明的位置 76 2.11.3 全局变量 77 2.11.4 静态变量 80 2.12 名称空间 80 2.12.1 声明名称空间 81 2.12.2 多个名称空间 82 2.13 C++/CLI编程 84 2.13.1 C++/CLI特有的基本数据类型 84 2.13.2 命令行上的C++/CLI输出 87 2.13.3 C++/CLI特有的功能—— 格式化输出 88 2.13.4 C++/CLI的键盘输入 91 2.13.5 使用safe_cast 92 2.13.6 C++/CLI枚举 92 2.14 查看C++/CLI类型 96 2.15 小结 97 2.16 练习 97 2.17 本章主要内容 98 第3章 判断和循环 101 3.1 比较数据值 101 3.1.1 if语句 102 3.1.2 嵌套的if语句 104 3.1.3 嵌套的if-else语句 107 3.1.4 逻辑运算符和表达式 109 3.1.5 条件运算符 112 3.1.6 switch语句 113 3.1.7 无条件转移 116 3.2 重复执行语句块 117 3.2.1 循环的概念 117 3.2.2 for循环的变体 119 3.2.3 while循环 126 3.2.4 do-while循环 128 3.2.5 嵌套的循环 129 3.3 C++/CLI编程 132 3.4 小结 137 3.5 练习 138 3.6 本章主要内容 138 第4章 数组、字符串和指针 139 4.1 处理多个相同类型的数据值 139 4.1.1 数组 140 4.1.2 声明数组 140 4.1.3 初始化数组 143 4.1.4 字符数组和字符串处理 144 4.1.5 多维数组 147 4.2 间接数据访问 150 4.2.1 指针的概念 150 4.2.2 声明指针 150 4.2.3 使用指针 152 4.2.4 初始化指针 152 4.2.5 sizeof操作符 158 4.2.6 常量指针和指向常量的指针 159 4.2.7 指针和数组 161 4.3 动态内存分配 168 4.3.1 堆的别名—— 空闲存储器 168 4.3.2 new和delete操作符 168 4.3.3 为数组动态分配内存 169 4.3.4 多维数组的动态分配 171 4.4 使用引用 172 4.4.1 引用的概念 172 4.4.2 声明并初始化lvalue引用 172 4.4.3 声明并初始化rvalue引用 173 4.5 字符串的本地C++库函数 174 4.5.1 查找以空字符结尾的字符串的长度 174 4.5.2 连接以空字符结尾的字符串 174 4.5.3 复制以空字符结尾的字符串 176 4.5.4 比较以空字符结尾的字符串 177 4.5.5 搜索以空字符结尾的字符串 177 4.6 C++/CLI编程 179 4.6.1 跟踪句柄 180 4.6.2 CLR数组 181 4.6.3 字符串 195 4.6.4 跟踪引用 203 4.6.5 内部指针 204 4.7 小结 206 4.8 练习 206 4.9 本章主要内容 207 第5章 程序结构(1) 209 5.1 理解函数 209 5.1.1 需要函数的原因 210 5.1.2 函数的结构 210 5.1.3 使用函数 213 5.2 给函数传递实参 216 5.2.1 按值传递机制 216 5.2.2 给函数传递指针实参 217 5.2.3 给函数传递数组 219 5.2.4 给函数传递引用实参 222 5.2.5 使用const修饰符 224 5.2.6 rvalue引用形参 225 5.2.7 main()函数的实参 227 5.2.8 接受数量不定的函数实参 229 5.3 从函数返回值 231 5.3.1 返回指针 231 5.3.2 返回引用 233 5.3.3 函数中的静态变量 236 5.4 递归函数调用 238 5.5 C++/CLI编程 240 5.5.1 接受数量可变实参的函数 241 5.5.2 main( )的实参 242 5.6 小结 243 5.7 练习 243 5.8 本章主要内容 244 第6章 程序结构(2) 245 6.1 函数指针 245 6.1.1 声明函数指针 246 6.1.2 函数指针作为实参 249 6.1.3 函数指针的数组 250 6.2 初始化函数形参 250 6.3 异常 252 6.3.1 抛出异常 253 6.3.2 捕获异常 254 6.3.3 MFC中的异常处理 255 6.4 处理内存分配错误 256 6.5 函数重载 257 6.5.1 函数重载的概念 258 6.5.2 引用类型和重载选择 260 6.5.3 何时重载函数 260 6.6 函数模板 261 6.7 使用decltype操作符 263 6.8 使用函数的示例 265 6.8.1 实现计算器 265 6.8.2 从字符串中删除空格 268 6.8.3 计算表达式的值 268 6.8.4 获得项值 270 6.8.5 分析数 271 6.8.6 整合程序 274 6.8.7 扩展程序 275 6.8.8 提取子字符串 277 6.8.9 运行修改过的程序 279 6.9 C++/CLI编程 279 6.9.1 理解泛型函数 280 6.9.2 CLR版本的计算器程序 285 6.10 小结 290 6.11 练习 291 6.12 本章主要内容 292 第7章 自定义数据类型 293 7.1 C++中的结构 293 7.1.1 结构的概念 294 7.1.2 定义结构 294 7.1.3 初始化结构 294 7.1.4 访问结构的成员 295 7.1.5 伴随结构的智能感知帮助 298 7.1.6 RECT结构 299 7.1.7 使用指针处理结构 300 7.2 数据类型、对象、类和实例 301 7.2.1 类的起源 303 7.2.2 类的操作 303 7.2.3 术语 303 7.3 理解类 304 7.3.1 定义类 304 7.3.2 声明类的对象 305 7.3.3 访问类的数据成员 305 7.3.4 类的成员函数 307 7.3.5 成员函数定义的位置 309 7.3.6 内联函数 309 7.4 类构造函数 310 7.4.1 构造函数的概念 311 7.4.2 默认的构造函数 312 7.4.3 在类定义中指定默认的形参值 314 7.4.4 在构造函数中使用初始化列表 316 7.4.5 声明显式的构造函数 317 7.5 类的私有成员 318 7.5.1 访问私有类成员 320 7.5.2 类的友元函数 321 7.5.3 默认复制构造函数 323 7.6 this指针 325 7.7 类的const对象 327 7.7.1 类的const成员函数 327 7.7.2 类外部的成员函数定义 328 7.8 类对象的数组 329 7.9 类的静态成员 331 7.9.1 类的静态数据成员 331 7.9.2 类的静态函数成员 334 7.10 类对象的指针和引用 334 7.10.1 类对象的指针 334 7.10.2 类对象的引用 337 7.11 C++/CLI编程 338 7.11.1 定义值类类型 339 7.11.2 定义引用类类型 344 7.11.3 定义引用类类型的复制构造函数 346 7.11.4 类属性 346 7.11.5 initonly字段 358 7.11.6 静态构造函数 360 7.12 小结 360 7.13 练习 360 7.14 本章主要内容 361 第8章 深入理解类 363 8.1 类析构函数 363 8.1.1 析构函数的概念 363 8.1.2 默认的析构函数 364 8.1.3 析构函数与动态内存分配 366 8.2 实现复制构造函数 369 8.3 在变量之间共享内存 370 8.3.1 定义联合 371 8.3.2 匿名联合 372 8.3.3 类和结构中的联合 372 8.4 运算符重载 373 8.4.1 实现重载的运算符 373 8.4.2 实现对比较运算符的完全支持 376 8.4.3 重载赋值运算符 379 8.4.4 重载加法运算符 384 8.4.5 重载递增和递减运算符 387 8.4.6 重载函数调用操作符 388 8.5 对象复制问题 389 8.5.1 避免不必要的复制操作 389 8.5.2 应用rvalue引用形参 392 8.5.3 命名的对象是lvalue 394 8.6 类模板 399 8.6.1 定义类模板 400 8.6.2 根据类模板创建对象 402 8.6.3 使用有多个形参的类模板 405 8.6.4 函数对象模板 406 8.7 使用类 407 8.7.1 类接口的概念 407 8.7.2 定义问题 407 8.7.3 实现CBox类 408 8.8 组织程序代码 425 8.9 字符串的本地C++库类 427 8.9.1 创建字符串对象 427 8.9.2 连接字符串 429 8.9.3 访问与修改字符串 432 8.9.4 比较字符串 436 8.9.5 搜索字符串 439 8.10 C++/CLI编程 447 8.10.1 在值类中重载运算符 447 8.10.2 重载递增和递减运算符 452 8.10.3 在引用类中重载运算符 453 8.10.4 实现引用类型的赋值运算符 455 8.11 小结 456 8.12 练习 456 8.13 本章主要内容 457 第9章 类继承和虚函数 459 9.1 面向对象编程的基本思想 459 9.2 类的继承 460 9.2.1 基类的概念 461 9.2.2 基类的派生类 461 9.3 继承机制下的访问控制 464 9.3.1 派生类中构造函数的操作 467 9.3.2 声明类的保护成员 470 9.3.3 继承类成员的访问级别 473 9.4 派生类中的复制构造函数 474 9.5 友元类成员 477 9.5.1 友元类 479 9.5.2 对类友元关系的限制 479 9.6 虚函数 479 9.6.1 虚函数的概念 481 9.6.2 使用指向类对象的指针 483 9.6.3 使用引用处理虚函数 485 9.6.4 纯虚函数 486 9.6.5 抽象类 487 9.6.6 间接基类 489 9.6.7 虚析构函数 491 9.7 类类型之间的强制转换 494 9.8 嵌套类 495 9.9 C++/CLI编程 498 9.9.1 装箱与拆箱 499 9.9.2 C++/CLI类的继承 499 9.9.3 接口类 505 9.9.4 定义接口类 505 9.9.5 类和程序集 509 9.9.6 被指定为new的函数 513 9.9.7 委托和事件 514 9.9.8 引用类的析构函数和终结器 525 9.9.9 泛型类 527 9.10 小结 536 9.11 练习 536 9.12 本章主要内容 539 第10章 标准模板库 541 10.1 标准模板库的定义 541 10.1.1 容器 542 10.1.2 容器适配器 542 10.1.3 迭代器 543 10.1.4 算法 544 10.1.5 STL中的函数对象 545 10.1.6 函数适配器 545 10.2 STL容器范围 545 10.3 序列容器 545 10.3.1 创建矢量容器 546 10.3.2 矢量容器的容量和大小 549 10.3.3 访问矢量中的元素 553 10.3.4 在矢量中插入和删除元素 553 10.3.5 在矢量中存储类对象 555 10.3.6 排序矢量元素 559 10.3.7 排序矢量中的指针 560 10.3.8 双端队列容器 562 10.3.9 使用列表容器 565 10.3.10 使用其他序列容器 574 10.4 关联容器 588 10.4.1 使用映射容器 589 10.4.2 使用多重映射容器 600 10.5 关于迭代器的更多内容 600 10.5.1 使用输入流迭代器 601 10.5.2 使用插入迭代器 604 10.5.3 使用输出流迭代器 605 10.6 关于函数对象的更多内容 607 10.7 关于算法的更多内容 608 10.7.1 fill() 608 10.7.2 replace() 609 10.7.3 find() 609 10.7.4 transform() 610 10.8 lambda表达式 611 10.8.1 capture子句 612 10.8.2 捕获特定的变量 613 10.8.3 模板和lambda表达式 613 10.8.4 包装lambda表达式 617 10.9 C++/CLI程序的STL 618 10.9.1 STL/CLR容器 619 10.9.2 使用序列容器 619 10.9.3 使用关联容器 627 10.10 C++/CLI中的lambda表达式 633 10.11 小结 633 10.12 练习 633 10.13 本章主要内容 634 第11章 调试技术 635 11.1 理解调试 635 11.1.1 程序故障 636 11.1.2 常见故障 637 11.2 基本的调试操作 638 11.2.1 设置断点 639 11.2.2 设置跟踪点 641 11.2.3 启动调试模式 641 11.2.4 修改变量的值 645 11.3 添加调试代码 645 11.3.1 使用断言 645 11.3.2 添加自己的调试代码 647 11.4 调试程序 652 11.4.1 调用栈 652 11.4.2 单步执行到出错位置 653 11.5 测试扩展的类 656 11.6 调试动态内存 659 11.6.1 检查空闲存储器的函数 660 11.6.2 控制空闲存储器的调试操作 661 11.6.3 空闲存储器的调试输出 662 11.7 调试C++/CLI程序 668 11.7.1 使用调试类Debug和跟踪类Trace 668 11.7.2 在Windows Forms应用程序中获得跟踪输出 676 11.8 小结 677 11.9 本章主要内容 677 第12章 Windows编程的概念 679 12.1 Windows编程基础 679 12.1.1 窗口的元素 680 12.1.2 Windows程序与操作系统 681 12.1.3 事件驱动型程序 682 12.1.4 Windows消息 682 12.1.5 Windows API 682 12.1.6 Windows数据类型 683 12.1.7 Windows程序中的符号 684 12.2 Windows程序的结构 685 12.2.1 WinMain()函数 686 12.2.2 消息处理函数 696 12.2.3 简单的Windows程序 700 12.3 Windows程序的组织 701 12.4 MFC 702 12.4.1 MFC表示法 702 12.4.2 MFC程序的组织方式 702 12.5 使用Windows Forms 706 12.6 小结 707 12.7 本章主要内容 707 第13章 多核编程 709 13.1 并行处理基本知识 709 13.2 并行模式库 710 13.3 并行处理算法 710 13.3.1 使用parallel_for算法 710 13.3.2 使用parallel_for_each算法 712 13.3.3 使用parallel_invoke算法 714 13.4 真正的并行问题 715 13.5 临界区 728 13.5.1 使用critical_section对象 728 13.5.2 锁定代码节或解除代码节锁定 729 13.6 combinable类模板 731 13.7 任务和任务组 733 13.8 小结 736 13.9 练习 736 13.10 本章主要内容 736 第14章 使用MFC编写Windows程序 739 14.1 MFC的文档/视图概念 739 14.1.1 文档的概念 739 14.1.2 文档界面 740 14.1.3 视图的概念 740 14.1.4 链接文档和视图 741 14.1.5 应用程序和MFC 742 14.2 创建MFC应用程序 743 14.2.1 创建SDI应用程序 745 14.2.2 MFC Application Wizard的输出 748 14.2.3 创建MDI应用程序 757 14.3 小结 760 14.4 练习 760 14.5 本章主要内容 760 第15章 处理菜单和工具栏 763 15.1 与Windows进行通信 763 15.1.1 了解消息映射 764 15.1.2 消息类别 767 15.1.3 处理程序中的消息 767 15.2 扩展Sketcher程序 768 15.3 菜单的元素 769 15.4 为菜单消息添加处理程序 771 15.4.1 选择处理菜单消息的类 773 15.4.2 创建菜单消息函数 773 15.4.3 编写菜单消息函数的代码 775 15.4.4 添加更新用户界面的消息处理程序 778 15.5 添加工具栏按钮 781 15.5.1 编辑工具栏按钮的属性 782 15.5.2 练习使用工具栏按钮 783 15.5.3 添加工具提示 784 15.6 C++/CLI程序中的菜单和工具栏 785 15.6.1 理解Windows Forms 785 15.6.2 理解Windows Forms应用程序 786 15.6.3 在CLR Sketcher中添加菜单 788 15.6.4 添加菜单项的事件处理程序 790 15.6.5 实现事件处理程序 791 15.6.6 设置菜单项复选 792 15.6.7 添加工具栏 793 15.7 小结 797 15.8 练习 797 15.9 本章主要内容 797 第16章 在窗口中绘图 799 16.1 窗口绘图的基础知识 799 16.1.1 窗口工作区 800 16.1.2 Windows图形设备界面 800 16.2 Visual C++中的绘图机制 802 16.2.1 应用程序中的视图类 802 16.2.2 CDC类 803 16.3 实际绘制图形 811 16.4 对鼠标进行编程 813 16.4.1 鼠标发出的消息 813 16.4.2 鼠标消息处理程序 814 16.4.3 使用鼠标绘图 816 16.5 练习使用Sketcher程序 837 16.5.1 运行示例 838 16.5.2 捕获鼠标消息 838 16.6 在CLR中绘图 840 16.6.1 在窗体上绘图 840 16.6.2 添加鼠标事件处理程序 840 16.6.3 定义C++/CLI元素类 842 16.6.4 实现MouseMove事件处理程序 850 16.6.5 实现MouseUp事件处理程序 851 16.6.6 实现窗体的Paint事件处理程序 851 16.7 小结 852 16.8 练习 852 16.9 本章主要内容 853 第17章 创建文档和改进视图 855 17.1 创建草图文档 855 17.2 改进视图 859 17.2.1 更新多个视图 859 17.2.2 滚动视图 861 17.2.3 使用MM_LOENGLISH映射模式 865 17.3 删除和移动形状 866 17.4 实现上下文菜单 866 17.4.1 关联菜单和类 867 17.4.2 练习弹出菜单 870 17.4.3 突出显示元素 870 17.4.4 处理菜单消息 874 17.5 处理屏蔽的元素 881 17.6 扩展CLR Sketcher 882 17.6.1 坐标系统转换 882 17.6.2 定义草图类 885 17.6.3 在Paint事件处理程序中绘制草图 886 17.6.4 实现元素的突出显示 887 17.6.5 创建上下文菜单 891 17.7 小结 897 17.8 练习 897 17.9 本章主要内容 898 第18章 使用对话框和控件 899 18.1 理解对话框 899 18.2 理解控件 900 18.3 创建对话框资源 900 18.3.1 给对话框添加控件 901 18.3.2 测试对话框 902 18.4 对话框的编程 902 18.4.1 添加对话框类 902 18.4.2 模态和非模态对话框 903 18.4.3 显示对话框 903 18.5 支持对话框控件 906 18.5.1 初始化控件 906 18.5.2 处理单选按钮消息 907 18.6 完成对话框的操作 908 18.6.1 给文档添加线宽 908 18.6.2 给元素添加线宽 909 18.6.3 在视图中创建元素 910 18.6.4 练习使用对话框 910 18.7 使用微调按钮控件 911 18.7.1 添加Scale菜单项和工具栏按钮 911 18.7.2 创建微调按钮 911 18.7.3 生成比例对话框类 913 18.7.4 显示微调按钮 915 18.8 使用缩放比例 916 18.8.1 可缩放的映射模式 916 18.8.2 设置文档的大小 917 18.8.3 设置映射模式 918 18.8.4 同时实现滚动与缩放 919 18.9 使用CTaskDialog类 921 18.9.1 显示任务对话框 921 18.9.2 创建CTaskDialog对象 923 18.10 使用状态栏 925 18.11 使用列表框 929 18.11.1 删除比例对话框 929 18.11.2 创建列表框控件 929 18.12 使用编辑框控件 931 18.12.1 创建编辑框资源 931 18.12.2 创建对话框类 933 18.12.3 添加Text菜单项 934 18.12.4 定义文本元素 935 18.12.5 实现CText类 935 18.13 CLR Sketcher中的对话框和控件 940 18.13.1 添加对话框 940 18.13.2 创建文本元素 946 18.14 小结 953 18.15 练习 953 18.16 本章主要内容 953 第19章 存储和打印文档 955 19.1 了解序列化 955 19.2 序列化文档 956 19.2.1 文档类定义中的序列化 956 19.2.2 文档类实现中的序列化 957 19.2.3 基于CObject的类的功能 959 19.2.4 序列化的工作方式 960 19.2.5 如何实现类的序列化 961 19.3 应用序列化 961 19.3.1 记录文档修改 962 19.3.2 序列化文档 963 19.3.3 序列化元素类 965 19.4 练习序列化 968 19.5 打印文档 969 19.6 实现多页打印 972 19.6.1 获取文档的总尺寸 973 19.6.2 存储打印数据 973 19.6.3 准备打印 974 19.6.4 打印后的清除 976 19.6.5 准备设备上下文 976 19.6.6 打印文档 977 19.6.7 获得文档的打印输出 980 19.7 CLR Sketcher中的序列化和打印 981 19.7.1 了解二进制序列化 981 19.7.2 序列化草图 985 19.7.3 打印草图 995 19.8 小结 996 19.9 练习 996 19.10 本章主要内容 997 第20章 编写自己的DLL 999 20.1 了解DLL 999 20.1.1 DLL的工作方式 1000 20.1.2 DLL的内容 1003 20.1.3 DLL变体 1003 20.2 决定放入DLL的内容 1004 20.3 编写DLL 1005 20.4 小结 1011 20.5 练习 1011 20.6 本章主要内容 1011 前言   欢迎使用本书。通过学习本书,您可以使用Microsoft公司最新的应用程序开发系统,成为优秀的C++程序员。本书旨在讲述C++程序设计语言,然后讲述如何运用C++语言开发自己的Windows应用程序。在此过程中,读者将了解这一最新Visual C++版本所提供的很多激动人心的新功能,包括如何在自己的应用程序中充分利用多核处理器。   0.1 使用C++语言编程   Visual C++ 2010支持两种截然不同但又紧密相关的C++语言,即ISO/IEC标准C++(本书称其为本地C++)和C++/CLI。虽然很多专业开发人员选用本地C++,尤其是当性能是需要考虑的主要因素时,但是C++/CLI和Windows Forms应用程序带来的开发速度和简易性使得C++/CLI也成了基本的语言。因此,本书将深入讨论这两种版本的C++语言。   Visual C++ 2010完全支持原来的ISO/IEC标准C++语言,同时还支持即将发布的ISO/IEC标准C++提供的一些功能强大的新特性。因此,本书不仅涵盖ISO/IEC标准C++的原有功能,同时还会介绍新语言特性。   Visual C++ 2010也支持C++/CLI,它是Microsoft公司作为本地C++的扩展而开发的C++版本。C++/CLI背后的思想是向本地C++添加一些特性,从而能够开发以.NET支持的虚拟机环境为目标的应用程序。这就将C++添加到能使用.NET Framework的其他语言(例如,BASIC和C#)中。C++/CLI语言目前是一个ECMA标准,同时也符合定义.NET虚拟机环境的CLI标准。   Visual C++ 2010的这两种C++版本互为补充,各自完成不同的任务。ISO/IEC C++用于开发在本地计算机上运行的高性能应用程序,而C++/CLI专门为.NET Framework开发应用程序。掌握了使用这两种C++版本开发应用程序的基础知识之后,就能够充分利用Visual C++ 2010。   0.2 开发Windows应用程序   充分理解C++之后,就可以着手开发Windows应用程序。Microsoft基本类(Microsoft Foundation Classes,MFC)封装了Windows API,提供了全面而易于使用的功能,从而能够使用本地C++开发高性能的Windows应用程序。   当编写本地C++程序时,可以从自动生成的代码中获得大量帮助,但仍然需要亲自编写大量C++代码。我们不仅需要对面向对象编程(OOP)技术有扎实的理解,而且需要充分了解Windows编程所涉及的各个方面。本书会介绍所有这些知识点。   C++/CLI虽然针对.NET Framework开发,但同时也是Windows Forms应用程序开发的载体。开发Windows Forms应用程序时,在不用编写一行代码的情况下,即使不能创建应用程序交互所需的用户界面的所有元素,也可以创建其中的很多元素。当然,仍然需要定制Windows Forms应用程序,才能完成相应的任务,但开发时间与使用本地C++创建应用程序相比只占一小部分。当给Windows Forms应用程序添加定制代码时,即使这部分代码只占到代码总量的很小比例,也仍然要求我们深入理解C++/CLI语言,才能做到游刃有余。本书旨在介绍这些知识。   0.3 高级库功能   并行模式库(Parallel Patterns Library,PPL)是Visual C++ 2010增加的一个令人激动的新功能,通过此功能,我们可以轻松编写使用多处理器的程序。在过去,为多处理器编程并非易事,但有了PPL,这就确实变得很容易了。本书将介绍PPL的各种使用方式,从而加快计算密集型应用程序的执行速度。   0.4 本书读者对象   本书针对任何想要学习如何使用Visual C++ 2010编写在Microsoft Windows操作系统下运行的C++应用程序的读者。阅读本书不需要预先具备任何特定编程语言的知识。如果属于下列4种情形之一,您就适合学习本教程:   ·属于编程新手,十分渴望投入编程世界,并最终掌握C++。要取得成功,您至少需要对计算机的工作原理有大体的理解——包括内存的组织方式以及数据和指令的存储方式。   ·具备一些其他语言的编程经验,如BASIC;渴望学习C++,并想提升实际的Microsoft Windows编程技能。   ·有一些使用C语言或C++语言的经验,但使用环境不是Microsoft Windows;希望使用最新的工具和技术,扩展在Windows环境下编程的技能。   ·有一些C++知识,并希望扩展C++技能,成为会使用C++/CLI的编程人员。   0.5 本书主要内容   本书实质上涵盖了两大主题:C++编程语言以及如何使用MFC或.NET Framework编写Windows应用程序。在开发完全成熟的Windows应用程序之前,需要具备相当水平的C++知识,因此,首先学习这本C++教程。 .  本书的第一部分通过可运行于两种C++语言版本上的一个详细的循序渐进式教程,讲授了使用Visual C++ 2010支持的两种C++语言技术编写C++程序的基础知识。您将了解本地ISO/IEC C++语言的语法和用法,并通过一系列范围广泛的可工作示例,获得实际运用它的经验和信心。本书也提供了一些练习,可以检验所学的知识,并且可以下载练习题答案。而C++/CLI作为本地C++的扩展来学习,这仍然是通过一些可运行的示例来说明每一个特性的工作原理。   当然,本语言教程也介绍和说明了C++标准库功能的用法,因为开发程序时极有可能使用它们。随着深入地学习C++语言,您的标准库知识会不断增加。还将学习标准模板库(Standard Template Library,STL)以两种形式——即本地C++版本和C++/CLI版本——提供的强大工具。另外,本书还用一章的篇幅专门讲述新增的并行模式库(PPL)功能,从而能够利用PC的多核处理功能来开发计算密集型应用程序。   对C++的运用有信心之后,就可以继续学习Windows编程了。通过创建超过2000行代码的大型可运行的应用程序,学习如何使用MFC来开发本地Windows应用程序。开发此应用程序贯穿多章内容,使用到了MFC提供的一系列用户界面功能。为学习如何使用C++/CLI编写Windows程序,相应地开发了一个与本地C++应用程序具有相似用户界面特性的Windows Forms应用程序。   0.6 本书结构   本书内容的结构安排如下:   ·第1章介绍使用C++编写本地应用程序和.NET Framework应用程序所需要理解的基本概念,以及在Visual C++ 2010开发环境中体现的主要思想,还叙述了如何使用Visual C++ 2010的功能来创建本书其余部分要学习的各种C++应用程序。   ·第2~9章讲授两种C++语言版本。第2~9章内容的组织方式都相似:各章的前半部分讨论本地C++语言的元素,后半部分讨论如何在C++/CLI中提供相同的功能。   ·第10章介绍如何使用标准模板库(Standard Template Library,STL)。STL是一组功能强大且全面的工具,用来组织和操作本地C++程序中的数据。由于STL是独立于应用程序的,因此可以在上下文中大量应用它。第10章还介绍了Visual C++ 2010新增的STL/CLR。它是C++/CLI应用程序的STL版本。   ·第11章介绍了在C++程序中查找错误的技术。涵盖了调试程序的一般原则,以及Visual C++ 2010提供的基本特性,这些特性可以帮助我们查找代码中的错误。   ·第12章讨论Microsoft Windows应用程序的组织方式,并描述和展示了在所有Windows应用程序中都存在的基本元素。本章解释了以本地C++语言编写的、使用Windows API和MFC的Windows应用程序示例,还给出了一个使用C++/CLI语言编写的Windows Forms应用程序的基础示例。   ·第13章介绍了如何在PC有多核处理器的情况下编写程序以使用多个处理器。通过一些完整的工作示例展示了并行处理的基本技术,这些示例Windows API应用程序是计算密集型程序。   ·第14~19章讲述Windows编程。详细描述了如何使用MFC提供的构建GUI的功能编写本地C++ Windows应用程序以及如何在C++/CLI Windows应用程序中使用.NET Framework。我们将学习如何创建并使用通用控件来构建应用程序的图形用户界面,还将学习如何处理因用户与程序的交互作用而产生的事件。除了学习构建GUI的技术以外,还将从开发该应用程序的过程中学到如何打印文档,以及如何在磁盘上保存应用程序数据。   ·第20章讲述为使用MFC创建自己的库而需要知道的基本知识。我们将了解可以创建的不同种类的库,还将开发能够与前6章开发的应用程序协同工作的示例。   本书各章内容都包括许多工作示例,通过这些示例阐明所讨论的编程技术。每章结束时都总结了该章所讲述的要点,大多数章节都在最后给出了一组练习,您可以应用所学的技术来试着解答这些练习。练习的答案连同书中的所有代码都可以从http://www.wrox.com和http://www.tupwk.com.cn/ downpage下载。关于C++语言教程使用的示例都是使用简单的命令行输入和输出的控制台程序。这种方法使我们能够在不陷入复杂的Windows GUI编程的情况下,学习C++的各种功能。实际上,只有在透彻地理解编程语言之后,才能进行Windows 编程。   如果希望使学习过程尽可能简单,或者如果您是程序设计初学者,那么最初可以只学习本地C++编程语言。讲授C++语言的各章(第2~9章)都是首先讨论本地C++功能的特定方面,然后再讨论C++/CLI在相同的上下文中引入的新功能。以这种方式组织各章内容的原因在于,C++/CLI是作为ISO/IEC标准语言的扩展定义的,对C++/CLI的理解是以对ISO/IEC C++的理解为基础的。因此,您可以只阅读各章中的本地C++部分,而忽略后面的C++/CLI部分。然后可以继续使用本地C++开发Windows应用程序,而免去记住两种语言版本的苦恼。在熟悉了ISO/IEC C++之后,您可以回头重新学习C++/CLI。当然,如果您已经有一些编程经验,也可以逐章进行学习,从而同步增加这两种C++语言版本的知识。   0.7 使用本书的前提   为了充分地使用本书,需要可支持MFC的某个Visual C++ 2010(或Visual Studio 2010)版本。需要注意的是,免费的Visual C++ 2010 Express Edition版本是不行的。因为此版本只提供C++编译器以及对基本Windows API的访问,并没有提供MFC库。因此,Visual C++ 2010(或Visual Studio 2010)的任何付费版本都能够编译并执行本书的所有示例。   0.8 源代码   读者在阅读本书提供的代码时,既可以亲自输入所有代码,也可以使用随书提供的代码文件。本书所有代码均可以从http://www.wrox.com/或www.tupwk.com.cn/downpage网站下载。进入该网站后,读者可以根据本书的书名查找本书(既可以使用搜索框,也可以使用书名列表进行查找),然后单击本书详细内容页面上提供的Download Code链接,就可以下载本书提供的所有代码。   注意:   由于许多书籍名称与本书类似,读者也可以通过ISBN进行查找,本书的ISBN为:978-0-470-50088-0。   另外,读者可以从前面提到的CodePlex网站下载本书或其他Wrox书籍的代码,也可以从Wrox的代码下载页面http://www.wrox.com/dynamic/books/download.aspx和http://www. tupwk.com.cn/downpage下载本书或其他Wrox书籍的代码。   源代码下载成功后,读者用任一解压工具将其解压即可。   0.9 勘误表   为了避免本书文字和代码中存在错误,我们已经竭尽全力。然而,世界上并不存在完美无缺的事物,所以本书可能仍然存在错误。如果读者在我们编写的某本书籍中发现了诸如拼写错误或代码缺陷等问题,那么请告诉我们,我们对此表示感谢。利用勘误表反馈错误信息,可以为其他读者节省大量时间,同时,我们也能够受益于读者的帮助,这样有助于我们编写出质量更高的专业著作。   如果读者需要参考本书的勘误表,请在网站http://www.wrox.com中用搜索框或书名列表查找本书书名。然后,在本书的详细内容页面上,单击Book Errata链接。在随后显示的页面中,读者可以看到与本书相关的所有勘误信息,这些信息是由读者提交、并由Wrox的编辑们加上的。通过访问http://www.wrox.com/misc-pages/booklist.shtml,读者还可以看到Wrox出版的所有书籍的勘误表。   如果读者没有在Book Errata页面上找到自己发现的错误,那么请转到页面http://www. wrox.com/contact/techsupport.shtml,针对您所发现的每一项错误填写表格,并将表格发给我们,我们将对表格内容进行认真审查,如果确实是我们书中的错误,我们将在该书的Book Errata页面上标明该错误信息,并在该书的后续版本中改正。   0.10 关于p2p.wrox.com网站   如果读者希望能够与作者进行讨论,或希望能够参与到读者的共同讨论中,那么请加入p2p.wrox.com论坛。该论坛是一个基于Web的系统,读者可以在论坛发表与Wrox出版的书籍及相关技术的信息,并与其他读者和技术用户进行讨论。论坛提供了订阅功能,可以将与读者所选定主题相关的新帖子定期发送到读者的电子邮箱。Wrox的作者、编辑、业界专家,以及其他读者都会参与论坛中的讨论。   读者可以在http://p2p.wrox.com参与多个论坛的讨论,这些论坛不仅能够帮助读者更好地理解本书,还有助于读者更好地开发应用程序。如果读者希望加入论坛,那么请按照以下步骤执行:   (1) 进入http://p2p.wrox.com页面,单击Register链接。   (2) 阅读使用条款,然后单击Agree按钮。   (3) 填写必要的信息及可选信息,然后单击Submit按钮。   (4) 随后读者会收到一封电子邮件,邮件中说明了如何验证账户并完成整个加入过程。   读者无须加入P2P论坛即可阅读论坛消息,但如果需要发表主题或发表回复,那么必须加入论坛。   成功加入论坛后,读者就可以发表新主题了。此时,读者还可以回复其他用户发表的主题。读者在任何时间都可以阅读论坛信息,如果需要论坛将新的信息发送到自己的电子邮箱,那么可以单击论坛列表中论坛名称旁的Subscribe to this Forum图标完成这项功能设置。   如果读者需要获得更多与Wrox P2P相关的信息,请阅读P2P FAQs,这样可以获得大量与P2P和Wrox出版的书籍相关的具体信息。阅读FAQs时,请单击P2P页面上的FAQs链接。   
CruiseYoung提供的带有详细书签的电子书籍目录 http://blog.csdn.net/fksec/article/details/7888251 该资料是《C语言入门经典(第4版)》的源代码及课后练习答案 对应的书籍资料见: C语言入门经典(第4版) 基本信息 原书名: Beginning C: From Novice to Professional, Fourth Edition 原出版社: Apress 作者: (美)Ivor Horton 译者: 杨浩 出版社:清华大学出版社 ISBN:9787302170839 上架时间:2008-4-15 出版日期:2008 年4月 开本:16开 页码:571 版次:4-1 编辑推荐    本书是编程语言先驱者Ivor Horton的经典之作,是C语言方面最畅销的图书品种之一,在世界范围内广受欢迎,口碑极佳。    本书的目标是使你在C语言程序设计方面由一位初学者成为一位称职的程序员。 内容简介   本书是编程语言先驱者Ivor Horton的经典之作,是C语言方面最畅销的图书品种之一。本书集综合性、实用性为一体,是学习C语言的优秀入门教材,在世界范围内广受欢迎,口碑极佳。书中除了讲解C程序设计语言,还广泛介绍了作为一名C程序设计人员应该掌握的必要知识,并提供了大量的实用性很强的编程实例。本书的目标是使你在C语言程序设计方面由一位初学者成为一位称职的程序员。读者基本不需要具备任何编程知识,即可通过本书从头开始编写自己的C程序。 作译者 作者   Ivor Horton是世界著名的计算机图书作家,主要从事与编程相关的咨询及撰写工作,曾帮助无数程序员步入编程的殿堂。他曾在IBM工作多年,能使用多种语言进行编程(在多种机器上使用汇编语言和高级语言),设计和实现了实时闭环工业控制系统。Horton拥有丰富的教学经验(教学内容包括C、C++、Fortran、PL/1、APL等),同时还是机械、加工和电子CAD系统、机械CAM系统和DNC/CNC系统方面的专家。IvorHorton还著有关于C、C++和Java的多部入门级好书,如《C语言入门经典(第4版)》和《C++入门经典(第3版)》。 译者   杨浩,知名译者,大学讲师,从事机械和计算机方面的教学和研究多年,发表论文数篇,参编和翻译的图书多达20余部,还曾多次获得市部级奖项。近几年一直在跟踪.NET技术的发展,积极从事.NET技术文档和图书的翻译工作。 目录 封面 -12 封底 572 前言 -9 目录 -6 第1章 C语言编程 1 1.1 创建C程序 1 1.1.1 编辑 1 1.1.2 编译 2 1.1.3 链接 2 1.1.4 执行 3 1.2 创建第一个程序 4 1.3 编辑第一个程序 4 1.4 处理错误 5 1.5 剖析一个简单的程序 6 1.5.1 注释 6 1.5.2 预处理指令 7 1.5.3 定义main()函数 7 1.5.4 关键字 8 1.5.5 函数体 8 1.5.6 输出信息 9 1.5.7 参数 10 1.5.8 控制符 10 1.6 用C语言开发程序 12 1.6.1 了解问题 12 1.6.2 详细设计 12 1.6.3 实施 13 1.6.4 测试 13 1.7 函数及模块化编程 13 1.8 常见错误 17 1.9 要点 17 1.10 小结 18 1.11 习题 18 第2章 编程初步 19 2.1 计算机的内存 19 2.2 什么是变量 21 2.3 存储数值的变量 21 2.3.1 整数变量 21 2.3.2 变量的命名 25 2.3.3 变量的使用 26 2.3.4 变量的初始化 28 2.3.5 算术语句 28 2.4 变量与内存 34 2.5 整数变量类型 35 2.5.1 无符号的整数类型 35 2.5.2 使用整数类型 36 2.5.3 指定整数常量 37 2.6 浮点数 38 2.7 浮点数变量 38 2.8 使用浮点数完成除法运算 39 2.8.1 控制小数位数 40 2.8.2 控制输出的字段宽度 41 2.9 较复杂的表达式 41 2.10 定义常量 44 2.10.1 极限值 46 2.10.2 sizeof运算符 49 2.11 选择正确的类型 50 2.12 强制类型转换 53 2.12.1 自动转换类型 53 2.12.2 隐式类型转换的规则 54 2.12.3 赋值语句中的隐式类型转换 54 2.13 再谈数值数据类型 55 2.13.1 字符类型 56 2.13.2 字符的输入输出 57 2.13.3 宽字符类型 60 2.13.4 枚举 60 2.13.5 存储布尔值的变量 63 2.13.6 复数类型 63 2.14 赋值操作的op=形式 66 2.15 数学函数 68 2.16 设计一个程序 69 2.16.1 问题 69 2.16.2 分析 69 2.16.3 解决方案 71 2.17 小结 75 2.18 练习 76 第3章 条件判断 79 3.1 判断过程 79 3.1.1 算术比较 80 3.1.2 涉及关系运算符的表达式 80 3.1.3 基本的if语句 81 3.1.4 扩展if语句:if-else 84 3.1.5 在if语句中使用代码块 86 3.1.6 嵌套的if语句 87 3.1.7 更多的关系运算符 90 3.1.8 逻辑运算符 93 3.1.9 条件运算符 97 3.1.10 运算符的优先级 99 3.2 多项选择问题 103 3.2.1 给多项选择使用else-if语句 104 3.2.2 switch语句 104 3.2.3 goto语句 113 3.3 按位运算符 114 3.3.1 按位运算符的op=用法 116 3.3.2 使用按位运算符 117 3.4 设计程序 120 3.4.1 问题 120 3.4.2 分析 120 3.4.3 解决方案 121 3.5 小结 124 3.6 练习 124 第4章 循环 127 4.1 循环 127 4.2 递增和递减运算符 128 4.3 for循环 129 4.4 for循环的一般语法 132 4.5 再谈递增和递减运算符 133 4.5.1 递增运算符 133 4.5.2 递增运算符的前置和后置形式 134 4.5.3 递减运算符 134 4.6 再论for循环 135 4.6.1 修改for循环变量 137 4.6.2 没有参数的for循环 138 4.6.3 循环内的break语句 138 4.6.4 使用for循环限制输入 141 4.6.5 生成伪随机整数 143 4.6.6 再谈循环控制选项 145 4.6.7 浮点类型的循环控制变量 146 4.7 while循环 147 4.8 嵌套循环 150 4.9 嵌套循环和goto语句 153 4.10 do-while循环 154 4.11 continue语句 157 4.12 设计程序 157 4.12.1 问题 157 4.12.2 分析 157 4.12.3 解决方案 158 4.13 小结 170 4.14 习题 170 第5章 数组 173 5.1 数组简介 173 5.1.1 不用数组的程序 173 5.1.2 什么是数组 175 5.1.3 使用数组 176 5.2 内存 179 5.3 数组和地址 182 5.4 数组的初始化 184 5.5 确定数组的大小 184 5.6 多维数组 185 5.7 多维数组的初始化 187 5.8 设计一个程序 191 5.8.1 问题 192 5.8.2 分析 192 5.8.3 解决方案 193 5.9 小结 200 5.10 习题 200 第6章 字符串和文本的应用 201 6.1 什么是字符串 201 6.2 处理字符串和文本的方法 203 6.3 字符串操作 206 6.3.1 连接字符串 206 6.3.2 字符串数组 208 6.4 字符串库函数 210 6.4.1 使用库函数复制字符串 210 6.4.2 使用库函数确定字符串的长度 211 6.4.3 使用库函数连接字符串 212 6.4.4 比较字符串 213 6.4.5 搜索字符串 216 6.5 分析和转换字符串 219 6.5.1 转换字符 222 6.5.2 将字符串转换成数值 225 6.7 使用宽字符串 225 6.8 设计一个程序 228 6.8.1 问题 229 6.8.2 分析 229 6.8.3 解决方案 229 6.9 小结 237 6.10 习题 237 第7章 指针 239 7.1 指针初探 239 7.1.1 声明指针 240 7.1.2 通过指针访问值 241 7.1.3 使用指针 244 7.1.4 指向常量的指针 248 7.1.5 常量指针 248 7.1.6 指针的命名 249 7.2 数组和指针 249 7.3 多维数组 252 7.3.1 多维数组和指针 255 7.3.2 访问数组元素 257 7.4 内存的使用 260 7.4.1 动态内存分配:malloc()函数 260 7.4.2 分配内存时使用sizeof运算符 261 7.4.3 用calloc()函数分配内存 265 7.4.4 释放动态分配的内存 265 7.4.5 重新分配内存 267 7.5 使用指针处理字符串 268 7.5.1 更多地控制字符串输入 268 7.5.2 使用指针数组 269 7.6 设计程序 280 7.6.1 问题 280 7.6.2 分析 281 7.6.3 解决方案 281 7.7 小结 291 7.8 习题 291 第8章 程序的结构 293 8.1 程序的结构 293 8.1.1 变量的作用域和生存期 294 8.1.2 变量的作用域和函数 297 8.2 函数 297 8.2.1 定义函数 298 8.2.2 return语句 301 8.3 按值传递机制 304 8.4 函数声明 305 8.5 指针用作参数和返回值 307 8.5.1 常量参数 310 8.5.2 从函数中返回指针值 318 8.5.3 在函数中递增指针 322 8.6 小结 322 8.7 习题 323 第9章 函数再探 325 9.1 函数指针 325 9.1.1 声明函数指针 325 9.1.2 通过函数指针调用函数 326 9.1.3 函数指针数组 329 9.1.4 作为变元的函数指针 331 9.2 函数中的变量 334 9.2.1 静态变量:函数内部的追踪 334 9.2.2 在函数之间共享变量 336 9.3 调用自己的函数:递归 338 9.4 变元个数可变的函数 341 9.4.1 复制va_list 344 9.4.2 长度可变的变元列表的基本规则 344 9.5 main()函数 345 9.6 结束程序 346 9.7 函数库:头文件 347 9.8 提高性能 348 9.8.1 内联声明函数 348 9.8.2 使用restrict关键字 348 9.9 设计程序 349 9.9.1 问题 349 9.9.2 分析 349 9.9.3 解决方案 351 9.10 小结 367 9.11 习题 368 第10章 基本输入和输出操作 369 10.1 输入和输出流 369 10.2 标准流 370 10.3 键盘输入 371 10.3.1 格式化键盘输入 371 10.3.2 输入格式控制字符串 372 10.3.3 输入格式字符串中的字符 377 10.3.4 输入浮点数的各种变化 378 10.3.5 读取十六进制和八进制值 379 10.3.6 用scanf()读取字符 381 10.3.7 scanf()的陷阱 383 10.3.8 从键盘上输入字符串 383 10.3.9 键盘的非格式化输入 384 10.4 屏幕输出 389 10.4.1 使用printf()格式输出到屏幕 389 10.4.2 转义序列 391 10.4.3 整数输出 392 10.4.4 输出浮点数 394 10.4.5 字符输出 395 10.5 其他输出函数 398 10.5.1 屏幕的非格式化输出 398 10.5.2 数组的格式化输出 399 10.5.3 数组的格式化输入 400 10.6 打印机输出 400 10.7 小结 401 10.8 习题 401 第11章 结构化数据 403 11.1 数据结构:使用struct 403 11.1.1 定义结构类型和结构变量 405 11.1.2 访问结构成员 405 11.1.3 未命名的结构 408 11.1.4 结构数组 408 11.1.5 表达式中的结构 411 11.1.6 结构指针 411 11.1.7 为结构动态分配内存 412 11.2 再探结构成员 414 11.2.1 将一个结构作为另一个结构的成员 414 11.2.2 声明结构中的结构 415 11.2.3 将结构指针用作结构成员 416 11.2.4 双向链表 420 11.2.5 结构中的位字段 423 11.3 结构与函数 424 11.3.1 结构作为函数的变元 424 11.3.2 结构指针作为函数变元 425 11.3.3 作为函数返回值的结构 426 11.3.4 修改程序 430 11.3.5 二叉树 433 11.4 共享内存 442 11.4.1 联合 442 11.4.2 联合指针 444 11.4.3 联合的初始化 444 11.4.4 联合中的结构成员 444 11.5 定义自己的数据类型 446 11.5.1 结构与类型定义(typedef)功能 446 11.5.2 使用typedef简化代码 447 11.6 设计程序 448 11.6.1 问题 448 11.6.2 分析 448 11.6.3 解决方案 448 11.7 小结 459 11.8 习题 459 第12章 处理文件 461 12.1 文件的概念 461 12.1.1 文件中的位置 462 12.1.2 文件流 462 12.2 文件访问 462 12.2.1 打开文件 463 12.2.2 文件重命名 465 12.2.3 关闭文件 465 12.2.4 删除文件 466 12.3 写入文本文件 466 12.4 读取文本文件 467 12.5 将字符串写入文本文件 470 12.6 从文本文件中读入字符串 471 12.7 格式化文件的输入输出 474 12.7.1 格式化文件输出 474 12.7.2 格式化文件输入 475 12.8 错误处理 477 12.9 再探文本文件操作模式 478 12.10 二进制文件的输入输出 479 12.10.1 指定二进制模式 479 12.10.2 写入二进制文件 480 12.10.3 读取二进制文件 480 12.11 在文件中移动 488 12.11.1 文件定位操作 489 12.11.2 找出我们在文件中的位置 489 12.11.3 在文件中设定位置 490 12.12 使用临时文件 496 12.12.1 创建临时文件 496 12.12.2 创建唯一的文件名 496 12.13 更新二进制文件 497 12.13.1 修改文件的内容 502 12.13.2 从键盘读取记录 503 12.13.3 将记录写入文件 504 12.13.4 从文件中读取记录 505 12.13.5 写入文件 506 12.13.6 列出文件内容 507 12.13.7 更新已有的文件内容 508 12.14 文件打开模式小结 515 12.15 设计程序 516 12.15.1 问题 516 12.15.2 分析 516 12.15.3 解决方案 516 12.16 小结 522 12.17 习题 522 第13章 支持功能 523 13.1 预处理 523 13.1.1 在程序中包含头文件 523 13.1.2 外部变量及函数 524 13.1.3 替换程序源代码 525 13.1.4 宏替换 526 13.1.5 看起来像函数的宏 526 13.1.6 多行上的预处理指令 528 13.1.7 字符串作为宏参数 528 13.1.8 结合两个宏展开式的结果 529 13.2 预处理器逻辑指令 530 13.2.1 条件编译 530 13.2.2 测试指定值的指令 531 13.2.3 多项选择 531 13.2.4 标准预处理宏 532 13.3 调试方法 533 13.3.1 集成的调试器 533 13.3.2 调试阶段的预处理器 533 13.3.3 使用assert()宏 537 13.4 其他库函数 539 13.4.1 日期和时间函数库 539 13.4.2 获取日期 543 13.5 小结 549 13.6 习题 549 附录A 计算机中的数学知识 551 附录B ASCII字符代码定义 559 附录C C语言中的保留字 565 附录D 输入输出格式指定符 567 前言   欢迎使用《C语言入门经典(第4版)》。研读本书,你就可以成为一位称职的C语言程序员。从许多方面来说,C语言都是学习程序设计的理想起步语言。C语言很简洁,因此无须学习大量的语法,就能够开始编写真正的应用程序。除了简明易学外,它还是一种功能非常强大的语言,至今仍被专业人士广泛使用。C语言的强大之处主要体现在,它能够进行各种层次的程序设计,从硬件设备驱动程序和操作系统组件到大规模的应用程序,都能胜任。事实上,任何计算机都支持C语言编译器,因此,当我们学会了C语言,就可以在任何环境下进行程序设计。最后一点,掌握了C语言,就为理解面向对象的C++语言奠定了良好的基础。.   积极热情的程序员都必将面对三大障碍,即掌握适用于所有程序设计语言的术语,理解如何使用一种语言的元素(而不仅仅只知道它们的概念)以及领会如何在实际环境中应用这种语言,本书的目的就是将这些障碍降到最低。   术语是专业人士与优秀的业余人士们进行交流时必不可少的,因此掌握它们是必需的。本书会让你理解这些术语,并自如地在各种环境下使用它们。这样才能更有效地使用大多数软件产品附带的文档,且能轻松地阅读和学习大多数程序设计语言的相关文献。   显然,理解语言元素的语法和作用是学习一门语言的关键,不过认识语言的特性如何发挥作用和如何应用它们,也同等重要。在说明每种语言特性与特定问题的关系时,本书采用实际应用的程序示例,而不只是代码片断。这些示例提供了实践的基础,你可以任意改动它们,研究改动后的效果。   要理解在特定背景中的程序设计方法,需要理解应用独立语言元素的机理。为了帮助理解它们,本书每章最后都给出一个较复杂的程序,该程序应用了本章前面已经学习的知识。这些程序可帮助你获得开发程序的能力和信心,了解如何综合运用各种语言元素。最重要的是,它们能让你了解设计真实程序时会遇到的问题以及如何管理实际的代码。   学习任何程序设计语言,都要认识几件事情。首先,要学的东西很多,但是掌握了它们之后,你会有极大的成就感。其次,学习的过程很有趣,你将体会到这一点。第三,你只有通过动手实践才能学会程序设计。最后,学习程序设计语言比你想象的容易得多,所以你肯定能掌握它。   如何使用本书   作者认为动手实践是最好的方法,你应当立刻开始编写自己的第一个程序。每一章都有几个把理论应用于实践的程序,这些示例是学习本书的关键。建议读者输入并运行文中的示例,因为输入程序对记住语言元素有极大的帮助。此外,你还应该做每章后面的练习。当你第一次使一个程序运行起来,尤其是在试图解决自己的问题时,快速的进展会使你有很大的成就感。..   刚开始,学习的进展不会太快,不过随着逐渐深入,我们会加快学习的速度。每一章都会涉及很多基础知识,因此在学习新的内容之前,需要花些时间,确保理解了前面学过的所有知识。实践各部分的代码,并尝试实现自己的想法,这是学习程序设计语言的一个重要部分。尝试修改书中的程序,看看还能让它们做什么,这是很有趣的。不要害怕尝试,如果不明白某一点如何使用,输入几种变体,看看会出现哪些情况。好的学习方法是先通读整章,全面了解其中介绍的内容,然后再实践其中的所有程序示例。   你可能会觉得某些章末尾的程序非常难。如果第一次读这样的程序没有完全理解,不必担心。第一次难免会觉得难以理解,因为它们通常都是把你所学的知识应用到了相当复杂的问题中。如果你真的不能理解,可以略过那些章末尾的程序,继续学习下一章,然后再回头研究这些程序。甚至可以在学完全书之后再来研究它们。之所以演示这些程序是因为即使读完了本书,它们对你来说仍是非常有用的资源。   本书读者对象   本书的目的是教你如何尽可能简单快速地编写有用的程序,如果你属于下列情况之一,那么本书就非常适合你:   ●刚接触程序设计,但想直接深入了解C语言,从头开始学习程序设计及编写C语言程序。   ●以前有一点程序设计经历,对其基本概念有一定了解,也许曾经使用过BASIC或PASCAL。现在想学习C语言,进一步提高自己的程序设计技能。   本书并未假设此前你对程序设计的知识有所了解,不过本书会很快地从基本概念转入到实际应用。学完了本书,你就为自己的C语言程序设计奠定了全面的基础。   使用本书的条件   要使用本书,需要一台安装了C语言编译器和库的计算机,这样才能执行书中的示例,还需要一个程序文本编辑器,用于创建源代码文件。你使用的编译器要很好地支持C语言国际标准:ISO/IEC 9899。你还需要一个用于创建和修改代码的编辑器,可以采用任何纯文本编辑器创建源程序文件,如Notepad或vi。不过,采用专为编辑C语言代码设计的编辑器更有帮助。   要最大限度地发挥本书的功效,你需要有学习的意愿、成功的渴望,当学习不顺利,觉得前途渺茫时,还要有坚持下去的决心。几乎每个人在初次学习程序设计时都会在某处觉得迷茫。当你发现自己艰难地掌握了C语言的某个方面时,要坚持下去,迷雾一定会消散,你会觉得为什么当初我不明白这一点呢?也许你明白要做到这些将会很难,不过相信你一定会惊讶自己能在较短的时间内取得很大进步。本书会帮助你开始自己的实践之旅,使你成为成功的程序设计员。   本书采用的约定   本书的文本和布局采用了许多不同的样式,以便区分各种不同的信息。大多数样式表达的含义都很明显,其中程序代码以类似下面的样子出现: .  int main(void)   {   printf("\nBeginning C");   return 0;   }   如果代码片段是从前面的实例修改而来的,修改过的代码行就用粗体显示,如下所示:   int main(void)   {   printf("\nBeginning C by Ivor Horton");   return 0;   }   程序代码中还使用了各种“括号”。它们之间的差别非常重要,不能互换。本书中称( )为圆括号,{ }为大括号,[ ]为方括号。   本书源代码下载   从Apress的站点可以下载本书中的所有代码和练习的解决方案:http://www.apress.com。也可以访问www.tupwk.com.cn/downpage下载本书中的所有代码和解决方案。...   
CruiseYoung提供的带有详细书签的电子书籍目录 http://blog.csdn.net/fksec/article/details/7888251 该资料是《Visual C++ 2005入门经典》的源代码及课后练习答案 对应的书籍资料见: Visual C++ 2005入门经典 基本信息 原书名: Ivor Horton's Beginning Visual C++ 2005 原出版社: Wiley 作者: (美)Ivor Horton 译者: 李颂华 康会光 出版社:清华大学出版社 ISBN:9787302142713 上架时间:2007-2-12 出版日期:2007 年1月 开本:16开 页码:1046 版次:1-1 编辑推荐   本书由编程语言先驱者Ivor Horton倾力而著,是国内第一本全面、深入介绍Visual C++ 2005的经典之作! 内容简介   本书系编程语言先驱者Ivor Horton的经典之作,是学习C++编程最畅销的图书品种之一,不仅涵盖了Visual C++ .NET编程知识,还全面介绍了标准C++语言和.NET C++/CLI。本书延续了Ivor Horton讲解编程语言的独特方法,从中读者可以学习Visual C++ 2005的基础知识,并全面掌握在MFC和Windows Forms中访问数据源的技术。此外,本书各章后面的习题将有助于读者温故而知新,并尽快成为C++高效程序员。...    作译者   Ivor Horton是世界著名的计算机图书作家,主要从事与编程相关的顾问及撰写工作,曾帮助无数程序员步入编程的殿堂。他曾在IBM工作多年,能使用多种语言进行编程(在多种机器上使用汇编语言和高级语言),设计和实现了实时闭环工业控制系统。Horton拥有丰富的教学经验(教学内容包括C、C++、Fortran、PL/1、APL等),同时还是机械、加工和电子CAD系统、机械CAM系统和DNC/CNC系统方面的专家。Ivor Horton还著有Beginning Visual C++ 6、Beginning C Programming和Beginning Java 2等多部入门级好书。 目录 封面 -18 前言 -14 目录 -9 第1章 使用Visual C++ 2005编程 1 1.1 .NET Framework 1 1.2 CLR 2 1.3 编写C++应用程序 3 1.4 学习Windows编程 4 1.4.1 学习C++ 4 1.4.2 C++标准 5 1.4.3 控制台应用程序 5 1.4.4 Windows编程概念 6 1.5 集成开发环境简介 7 1.6 使用IDE 9 1.6.1 工具栏选项 9 1.6.2 可停靠的工具栏 10 1.6.3 文档 11 1.6.4 项目和解决方案 11 1.6.5 设置Visual C++ 2005的选项 23 1.6.6 创建和执行Windows应用程序 24 1.6.7 创建Windows Forms应用程序 26 1.7 小结 29 第2章 数据、变量和计算 31 2.1 C++程序结构 31 2.1.1 程序注释 36 2.1.2 #include指令——头文件 37 2.1.3 命名空间和using声明 37 2.1.4 main()函数 38 2.1.5 程序语句 38 2.1.6 空白 40 2.1.7 语句块 41 2.1.8 自动生成的控制台程序 41 2.2 定义变量 42 2.2.1 命名变量 43 2.2.2 C++中的关键字 43 2.2.3 声明变量 44 2.2.4 变量的初值 44 2.3 基本数据类型 45 2.3.1 整型变量 45 2.3.2 字符数据类型 46 2.3.3 整型修饰符 47 2.3.4 布尔类型 48 2.3.5 浮点类型 48 2.3.6 ISO/ANSI C++中的基本类型 49 2.3.7 字面值 50 2.3.8 定义数据类型的同义词 50 2.3.9 具有特定值集的变量 51 2.3.10 指定枚举常量的类型 52 2.4 基本的输入/输出操作 53 2.4.1 从键盘输入 53 2.4.2 到命令行的输出 53 2.4.3 格式化输出 54 2.4.4 转义序列 55 2.5 C++中的计算 57 2.5.1 赋值语句 57 2.5.2 算术运算 58 2.5.3 计算余数 63 2.5.4 修改变量 63 2.5.5 增量和减量运算符 64 2.5.6 计算

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值