拓展题系列I之科普系列

最新推荐文章于 2023-04-03 13:41:56 发布

QlNG

最新推荐文章于 2023-04-03 13:41:56 发布

阅读量1k

点赞数

分类专栏： -【开发语言/框架】 __+【C/C++】

本文链接：https://blog.csdn.net/QlNG/article/details/24558013

版权

-【开发语言/框架】同时被 2 个专栏收录

2 篇文章 0 订阅

订阅专栏

__+【C/C++】

2 篇文章 0 订阅

订阅专栏

拓展题系列I之科普系列（共10道题目，总分15分，结算时，将你所得的分数换算成5分制，如：得了9分就是3分）：

1.编写一段代码，要求输出分别“烫烫烫...”和“屯屯屯...”，并简要说明原因。(2分)

2.C++小知识：
(1).C++中函数的默认参数. 可以查看： C++ Primer Plus 275页.
(2).C++中函数重载. 可以查看：C++ Primer Plus 277页.
(3).C++中函数模板和函数模板重载. 可以查看：C++ Primer Plus 281，283页.
要求：每个小知识，写一段代码说明，最好简要注释。（2分）

3.（C语言）搜索了解#include <string.h>头文件中的：strncpy(),strncmp(),strtok(),memset(),memcpy(),memcmp()
每个函数写一个程序发给我。（2分）

4.（C语言）搜索了解"单指针（int *p）"，"指针数组（int *p[]）"，"数组指针（即行指针）int (*p)[]"的用法。
结合一维，二维数组，编写相应的程序说明上述指针的使用方法。（2分）

5.（C语言）了解文件的几种操作方式：（3分）
搜索如下几个函数的使用方法：fgets(),fputs(),fscanf(),fprintf(),fread(),fwrite(),fgetc(),fputc();
要求：分别写代码说明。

6.（C++）区别一下如下几个函数：cin, cin.get(), cin.getline();
要求：编写代码并写简要说明。（1分）

7.（C语言）搜索printf()函数，明白其传参顺序。（0.5分）
示例：
int a = 1;
printf("%d,%d\n",a,++a);//输出：2,2 （为什么?）

8.（C语言）科普：如下程序不是死循环,解释原因。（0.5）
int i = 20;
while (i > 1)
{
++i;
}

9.（C语言）论const,要求：说明下面的几种情况都是什么只读?（1分）
int a = 1;
const int *p1 = &a;
int const *p2 = &a;
int *const p3 = &a;
const int *const p4 = &a;

10.(C语言)搜索了解main()函数中两个参数都是什么意思?要求：简单说明。（1分）
#include "stdafx.h"

int main(int argc, char* argv[])
{
printf("Hello World!\n");
return 0;

}

——————————————————————————————————————————————

1.编写一段代码，要求输出分别“烫烫烫...”和“屯屯屯...”，并简要说明原因。(2分)

#include <stdio.h>
#include <malloc.h>

int main()
{
	char a[6];
	char *b = (char *)malloc(6 * sizeof(char));
	
	a[6] = '\0';
	b[6] = '\0';

	puts(a);
	puts(b);

	return 0;
}

这里出现的”烫”其实是因为VS中调试器默认的字符集是MBCS，而在MBCS中0xCCCC正好就是中文中的”烫”，所以就出现了我们熟悉的烫内存！

至于“屯”，是因为如果在堆中分配的内存，即用new 命令分配的，默认的值是0xCD。而0xCDCD在MBCS字符集里正好是“屯”。

参考文章：imjustice 的学习笔记，http://www.cnblogs.com/imjustice/archive/2012/03/05/2623915.html

2.C++小知识：

(1).C++中函数的默认参数.

#include <iostream>
using namespace std;

void print(int a, int b = 4, int c = 12);

int main()
{
	print(2014,5);

	return 0;
}

void print(int a, int b, int c)
{
	cout<<a<<"/"<<b<<"/"<<c<<endl;
}

(2).C++中函数重载.

#include <iostream>
using namespace std;

void print(int a, int b);
void print(double a, double b);

int main()
{
	print(1, 2);
	print(1.2, 2.3);

	return 0;
}

void print(int a, int b)
{
	cout<<a+b<<endl;
}

void print(double a, double b)
{
	cout<<a+b<<endl;
}

(3).C++中函数模板和函数模板重载.

a.函数模板

#include <iostream>
using namespace std;

template <typename T>
void print(T a, T b);

int main()
{
	print(1, 2);
	print(1.2, 2.3);

	return 0;
}

template <typename T>
void print(T a, T b)
{
	cout<<a+b<<endl;
}

b.模板重载

#include <iostream>
using namespace std;

template <typename T>
void print(T a, T b);

template <typename T>
void print(T a, T b, int c);

int main()
{
	print(1, 2);
	print(1, 2, 3);

	return 0;
}

template <typename T>
void print(T a, T b)
{
	cout<<a+b<<endl;
}

template <typename T>
void print(T a, T b, int c)
{
	cout<<a+b+c<<endl;
}

3.（C语言）搜索了解#include <string.h>头文件中的：strncpy(),strncmp(),strtok(),memset(),memcpy(),memcmp()
每个函数写一个程序发给我。（2分）

（1）strncpy()

原型：char*strncpy(char*dest,char*src,size_tnum);

功能：将src字符串的前num个字符复制到dest中。

#include <stdio.h>
#include <string.h>

int main()
{
	char a[] = "abcdef";
    char b[10];

	strncpy(b,a,3);
	b[3] = '\0';  //注意给个尾部

	puts(b);

	return 0;
}

参考文章：百度百科strncpy()，http://baike.baidu.com/view/1207711.htm

（2）strncmp()

原型：int strncmp(char *str1, char *str2, int maxlen);

功能：按位比较字符串str1,str2前maxlen位的大小，str1>str2返回1，str1==str2，返回0，str1<str2返回-1

#include <stdio.h>
#include <string.h>

int main()
{
	char a[] = "abcdef";
    char b[] = "abcxyz";
	int n;

	n = strncmp(a,b,3);
	printf("1 : %d\n",n);
	n = strncmp(a,b,5);
	printf("2 : %d\n",n);

	return 0;
}

参考文章：百度百科strncmp()，http://baike.baidu.com/view/1028547.htm

（3）strtok()

原型：char *strtok( char *strToken, const char *strDelimit );

功能：分解字符串为一组字符串。s为要分解的字符串，delim为分隔符字符串。首次调用时，s指向要分解的字符串，之后再次调用要把s设成NULL。

原理：strtok遇到strDelimit所包含的分割符号，自动将其转化为'\0'.同时tok指针指向前面的那段字符串。

for()循环下一次将调用最近的缓存指针，就是从最近的'\0'开始下一轮寻找。直到寻找完，返回NULL给tok，结束。

a.单个分隔符

#include <stdio.h>
#include <string.h>

int main()
{
    char strToken[] = "This is my blog";
    char strDelimit[] = " ";
    char *tok;
    
    for (tok = strtok(strToken, strDelimit); tok != NULL; tok = strtok(NULL, strDelimit))
        puts(tok);
    
    return 0;
}

b.多个分隔符

#include <stdio.h>
#include <string.h>

int main()
{
    char strToken[] = "This,is my+blog";
    char strDelimit[] = ", +";
    char *tok;
    
    for (tok = strtok(strToken, strDelimit); tok != NULL; tok = strtok(NULL, strDelimit))
        puts(tok);
    
    return 0;
}

参考文章：

1.Dojking's Blog，关于strtok函数，http://www.cnblogs.com/jopus/p/3623801.html

2.推荐文章：liuintermilan的专栏，http://blog.csdn.net/liuintermilan/article/details/6280816

（4）memset()

原型：void *memset(void *s, int ch,size_t n);

功能：将s所指向的某一块内存中的前n个字节的内容全部设置为ch指定的ASCII值，块的大小由第三个参数指定，这个函数通常为新申请的内存做初始化工作，其返回值为指向S的指针。

a.将字符串a[]全部初始化为n

#include <stdio.h>
#include <string.h>

int main()
{
    char a[10];
    
	memset(a,'n',sizeof(char)*10);  //将a[10]全部初始化为'n'
	a[10] = '\0';
	puts(a);

    return 0;
}

b.给int型数组初始化

#include <stdio.h>
#include <string.h>

int main()
{
    int i,a[10];
    
	memset(a,0,sizeof(int)*10);  //将a[10]全部初始化为0,非0不可用memset初始化
	for (i = 0; i < 10; ++i)
		printf("%d",a[i]);
	printf("\n");

    return 0;
}

提示：可以正确的用0初始化整个数组，其他初始化都会出现错误，详情参见参考文章。

参考文章：百度百科，memset(),http://baike.baidu.com/view/982208.htm

（5）memcpy()

原型：void *memcpy(void *dest, const void *src, size_t n);

功能：从源src所指的内存地址的起始位置开始拷贝n个字节到目标dest所指的内存地址的起始位置中

a.拷贝字符

#include <stdio.h>
#include <string.h>

int main()
{
    char a[] = "abcdefg";
	char b[10];
    
	memcpy(b,a,3*sizeof(char)); 
	b[3] = '\0';
	puts(b);

    return 0;
}

b.拷贝数字

#include <stdio.h>
#include <string.h>

int main()
{
	int a[] = {1,2,3,4,5,6,7,8,9};
	int i,b[10];

	memcpy(b,a,3*sizeof(int));  //注意：第三个参数是字节

	for (i = 0; i < 3; ++i)
		printf("%d ",b[i]);
	printf("\n");

    return 0;
}

参考文章：百度百科，memcpy(),http://baike.baidu.com/view/736225.htm

（6）memcmp()

原型：int memcmp(const void *buf1, const void *buf2, unsigned int count);

功能：比较内存区域buf1和buf2的前count个字节。

a.比较字符串

#include <stdio.h>
#include <string.h>

int main()
{
	char a[] = "abcdefg";
	char b[] = "abcxyz";
	int n;
	
	n = memcmp(b,a,3*sizeof(char));  //注意：第三个参数是字节
	printf("%d\n",n);
	n = memcmp(b,a,5*sizeof(char));  
	printf("%d\n",n);
	
    return 0;
}

b.比较整数

#include <stdio.h>
#include <string.h>

int main()
{
	int a[] = {1,2,3,4,5,6,7,8,9};
	int b[] = {1,2,3,7,8,9};
	int n;
	
	n = memcmp(b,a,3*sizeof(int));  //注意：第三个参数是字节
	printf("%d\n",n);
	n = memcmp(b,a,5*sizeof(int));  
	printf("%d\n",n);
	
    return 0;
}

参考文章：百度百科，memcmp()，http://baike.baidu.com/view/1026877.htm

4.（C语言）搜索了解"单指针（int p）"，"指针数组（int p[]）"，"数组指针（即行指针）int (*p)[]"的用法。
结合一维，二维数组，编写相应的程序说明上述指针的使用方法。（2分）

（1）单指针（int *p）

#include <stdio.h>

int main()
{
	int a[] = {1,2,3,4,5};
	int *p = a;   //单指针

	while (p != a+5)
	{
		printf("%d ",*p);
		++p;
	}
	printf("\n");

    return 0;
}

（2）指针数组（int *p[]）

#include <stdio.h>

int main()
{
	char *p[] = {"abc","def","ghi","jkl"};  //指针数组
	int i;

	for (i = 0; i < 4; ++i)
		puts(p[i]);

    return 0;
}

（3）数组指针（int (*p)[]），也就是行指针。

#include <stdio.h>

int main()
{
	char arr[3][4] = {{'a','b','c','\0'},{'e','f','g','\0'},{'i','j','k','\0'}};
	char (*p)[4] = arr;      //行指针（数组指针：指向数组的一行）
	int i;

	for (i = 0; i < 3; ++i)
	{
		puts(p);
		++p;
	}

    return 0;
}

注释：二维数组的数组名其实就是一个行指针。（int (*p)[]）也就是指向数组的一行。

5.（C语言）了解文件的几种操作方式：（3分）
搜索如下几个函数的使用方法：fgets(),fputs(),fscanf(),fprintf(),fread(),fwrite(),fgetc(),fputc();
要求：分别写代码说明。

（1）fgets() ：每次从文件中读取一行数据。

原型：char*fgets(char*buf,intbufsize,FILE*stream);

参数：

*buf: 字符型指针，指向用来存储所得数据的地址。

bufsize: 整型数据，指明存储数据的大小。

*stream: 文件结构体指针，将要读取的文件流。

功能：如果使用fgets()读取某个文件，第一次读取的bufsize为5，而文件的第一行有10个字符（算上'\n'），那么读取文件的指针会偏移至当前读取完的这个字符之后的位置。也就是第二次再用fgets()读取文件的时候，则会继续读取其后的字符。而，如果使用fgets() 读取文件的时候bufsize大于该行的字符总数加2（多出来的两个，一个保存文件本身的'\n'换行，一个保存字符串本身的结束标识'\0'），文件并不会继续读下去，仅仅只是这一行读取完，随后指向文件的指针会自动偏移至下一行。

#include <stdio.h>

int main()
{
	FILE *fp = NULL;
	char buf[3][100];
	int i = 0;

	fp = fopen("File.txt","r");

	while (!feof(fp))
	{
		fgets(buf[i],100,fp);
		++i;
	}
	
	fclose(fp);

	for (i = 0; i < 3; ++i)
		puts(buf[i]);


    return 0;
}

注意：上述代码，必须首先自己在目录下新建一个File.txt文件，然后再里面输入一个字符。

参考文章：百度百科，fgets(),http://baike.baidu.com/view/656654.htm

（2）fputs() ：往文件中写入数据。

原型：intfputs(const char*str,FILE*fp);

参数：

str是字符型指针，可以是字符串常量，或者存放字符串的数组首地址。
fp是文件型指针，通过打开文件函数fopen()获得的。

功能：向指定的文件写入一个字符串（不自动写入字符串结束标记符‘\0’）。成功写入一个字符串后，文件的位置指针会自动后移，函数返回为一个非负整数；否则返回EOF(符号常量，其值为-1)。

注意：puts()不自动写入'\0'，同时也不会写入'\n'，下面测试一下：

#include <stdio.h>

int main()
{
	FILE *fp = NULL;
	char buf[3][100] = {"This is a file test","the second row","ok, test success"};
	int i = 0;

	fp = fopen("File.txt","w");

	while (i != 3)
	{
		fputs(buf[i],fp);
		++i;
	}
	
	fclose(fp);

    return 0;
}

参考文章：百度百科，fputs(),http://baike.baidu.com/view/656687.htm

（3）fscanf() ：从文件中读取数据。

原型：int fscanf(FILE *stream, const char*format, [argument...]);

参数：

FILE *stream ：文件指针；
char *format ：格式字符串；
[argument...] ：输入列表。

功能：从一个流中执行格式化输入，fscanf遇到空格和换行时结束，注意空格时也结束。这与fgets有区别，fgets遇到空格不结束。

#include <stdio.h>

int main()
{
	FILE *fp = NULL;
	char str[10];
	int n;

	fp = fopen("File.txt","r");

	fscanf(fp,"%s%d",str,&n);

	fclose(fp);

	printf("%s\n%d\n",str,n);

	return 0;
}

注意：执行上述代码的时候需要先在目录下面建立File.txt文件，并在里面输入数据。如输入："QING 2014" fscanf()读取时以空格和换行区分开的。

参考文章：百度百科，fscanf(),http://baike.baidu.com/view/656694.htm

（4）fprintf() ：往文件中写数据。

原型：int fprintf(FILE *stream, const char *format, [argument]);

参数：同上。

功能：fprintf是C/C++中的一个格式化写—库函数；其作用是格式化输出到一个流/文件中；

#include <stdio.h>

int main()
{
	FILE *fp = NULL;
	char str[10] = "QING";
	int n = 2014;

	fp = fopen("File.txt","w");

	fprintf(fp,"%s %d",str,n);//最好%s %d中间加个空格，方便以后读取

	fclose(fp);

	return 0;
}

参考文章：百度百科，fprintf(),http://baike.baidu.com/view/656682.htm

（5）fwrite() 和 fread() ：二进制文件操作，数据块操作。

函数名：fwrite()

原型：size_tfwrite(const void* buffer,size_tsize,size_tcount,FILE* stream);

参数：

注意：这个函数以二进制形式对文件进行操作，不局限于文本文件

返回值：返回实际写入的数据块数目

（1） buffer：是一个指针，对fwrite来说，是要获取数据的地址；

（2） size：要写入内容的单字节数；

（3） count:要进行写入size字节的数据项的个数；

（4） stream:目标文件指针；

（5）返回实际写入的数据项个数count。

功能：向文件写入一个数据块。

函数名：fread()

原型：size_t fread ( void *buffer, size_t size, size_t count, FILE *stream) ;

参数：

(1) buffer ：用于接收数据的内存地址
(2)size ：要读写的字节数，单位是字节
(3)count ：要进行读写多少个size字节的数据项,每个元素是size字节.
(4)stream ：输入流
返回值：
实际读取的元素个数.如果返回值与count不相同,则可能文件结尾或发生错误.
从ferror和feof获取错误信息或检测是否到达文件结尾.

#include <stdio.h>
#include <string.h>

typedef struct node
{
	char name[20];
	int age;
}MyNode;

int main()
{
	FILE *fp = NULL;
	MyNode node;

	strcpy(node.name,"QING");
	node.age = 20;

	fp = fopen("File.txt","w");
	fwrite(&node, sizeof(MyNode), 1, fp);//参数：结点指针，结点大小，读入个数，文件指针
	fclose(fp);

	/
	fp = fopen("File.txt","r");
	while (!feof(fp))
	{
		fread(&node, sizeof(MyNode), 1, fp);
	}
	fclose(fp);

	printf("%s\n%d\n",node.name, node.age);

	return 0;
}

参考文章：

1.百度百科，fwrite(),http://baike.baidu.com/view/656700.htm

2.百度百科，fread(),http://baike.baidu.com/view/656689.htm

(6) fgetc() ：从文件中每次读取一个字符.

原型：intfgetc(FILE*stream);

返回值：读取到的字符。如果读取到了文件尾部则返回EOF.

#include <stdio.h>

int main()
{
	FILE *fp = NULL;
	char str[100];
	int i = 0;

	fp = fopen("File.txt","r");
	while (!feof(fp))
	{
		str[i] = fgetc(fp);
		++i;
	}
	str[i] = '\0';  //给一个尾部
	fclose(fp);

	puts(str);

	return 0;
}

注意：执行上述代码的时候，需要首先新建一个"File.txt"文件，并且输入数据.

参考文章：百度百科,fgetc(),http://baike.baidu.com/view/656651.htm

（7）fputc() ：往文件每次写入一个字符.

原型：intfputc (int n, File *fp);

功能：将字符ch写到文件指针fp所指向的文件的当前写指针的位置。

#include <stdio.h>

int main()
{
	FILE *fp = NULL;
	char str[100] = "Welcome Qing's blog.";
	int i = 0;

	fp = fopen("File.txt","w");
	while (str[i] != '\0')
	{
		fputc(str[i],fp);
		++i;
	}
	fclose(fp);

	return 0;
}

参考文章：百度百科，fputc(),http://baike.baidu.com/view/656685.htm

6.（C++）区别一下如下几个函数：cin, cin.get(), cin.getline();
要求：编写代码并写简要说明。（1分）

cin：遇到空格，回车或者制表符就会结束输入，这样就导致了我们不能输入一个带有空格的字符串。

cin.get(),cin.getline() ：但是，很好，C++的这两个函数帮我们解决了这一问题，它们都表示每次读取一行字符串输入。

不过，这两个函数也有一些区别：

cin.getline()和cin.get()。这两个函数都读取一行输入，直到达到换行符。然而，随后cin.getline()将丢弃换行符，而cin.get()将换行符保留在输入序列中。

1.面向行的输入：getline()

MSDN中的用法：

istream::getline

istream& getline( char* pch, int nCount, chardelim= '\n' );

istream& getline( unsigned char* puch, int nCount, char delim = '\n' );

istream& getline( signed char* psch, int nCount, char delim = '\n' );

getline()函数读取整行，它使用通过回车键输入的换行符来确定输入结尾。要调用这种方法，可以使用cin.getline()。该函数有两个参数。第一个参数是用来储存输入行的数组名称，第二个参数是要读取的字符数。如果这参数为20，则函数最多读取19个字符，余下的空间用于储存自动在结尾处添加的空字符。getline()成员函数在读取指定数目的字符或者遇到换行符时停止读取。

例如，假设要使用getline()将姓名读入到一个包含20个元素的name数组中。可以使用这样的函数调用：

cin.getline(name, 20);

这将把一行读入到name数组中——如果这行包含的字符不超过19个。

#include <iostream>
using namespace std;

int main()
{
	char name[20];

	cin.getline(name,20);
	cout<<"name : "<<name<<endl;

	return 0;
}

getline()函数每次读取一行。它通过换行符来确定尾部，单不保存换行符。相反，在储存字符串时，它用空字符（'\0'）来替换换行符。

2.面向行输入：get()

MSDN中的用法：

get();
*get( char, int, char );**
get( char& );
get( streambuf&, char );

get()不读取并丢弃换行符，而是将其留在输入队列中。

例如，cin.get(name, 10); cin.get(blog, 10); 连续两个cin.get()。就出问题了。

由于第一次调用后，换行符将留在输入队列中，因此第二次调用时看到的第一个字符就是换行符。因此get()认为已经达到行尾，而没有发现任何读取内容。

如果不借助帮助，get()将不能跨过该换行符。

幸运的是，cin.get();不带任何参数，可以读取下一个字符（即使是换行符）。所以我们可以改成如下：

cin.get(name,10);

cin.get();

cin.get(blog,10);

这样问题就得到了解决。

#include <iostream>
using namespace std;

int main()
{
	char name[100],blog[100];

	cin.get(name,10);
	cin.get();
	cin.get(blog,10);

	cout<<"name : "<<name<<endl;
	cout<<"blog : "<<blog<<endl;

	return 0;
}

参考文献：Elohim's Blog，http://blog.csdn.net/elohims/article/details/23560743

7.（C语言）搜索printf()函数，明白其传参顺序。（0.5分）

示例：
int a = 1;
printf("%d,%d\n",a,++a);//输出：2,2 （为什么?）

#include <stdio.h>

int main()
{
	int a = 3, b = 3, c = 3, d = 3;

	printf("%d,%d\n",++a,a);  //4 , 3
	printf("%d,%d\n",b,++b);  //4 , 4
	printf("%d,%d\n",c,c++);  //3 , 3
	printf("%d,%d\n",d++, d); //3 , 3

	return 0;
}

由上面这个例子可以看出printf()函数传参是，从右往左开始传参的，同时需要注意 ++i 和 i++的区别。

8.（C语言）科普：如下程序不是死循环,解释原因。（0.5）

int i = 20;
while (i > 1)
{
++i;

}

注意：while ()循环中i的值一直在增大，当增大到int的最大值的时候，就会溢出，变成一个负数。从而跳出while()循环。

9.（C语言）论const,要求：说明下面的几种情况都是什么只读?（1分）

int a = 1;
const int *p1 = &a; 【A】
int const *p2 = &a; 【B】
int *const p3 = &a; 【C】

const int *const p4 = &a;【D】

为了方便，我们将上面的编号一下，A,B,C,D。

其实：【A】,【B】两种写法是一样的，作用：都是*p1只读，（指针本身是变量，指向的内容只读）。

【C】p3只读。（指针本身只读，指向的内容是变量）。

【D】p4,*p4都是只读。（指针本身，和指向的内容都是只读）。

巧妙记忆法：const在哪个前面哪个就是只读，比如【A】const在*p1前面。又如【C】const在p3前面。

10.(C语言)搜索了解main()函数中两个参数都是什么意思?要求：简单说明。（1分）

#include "stdafx.h"

int main(int argc, char* argv[])
{
printf("Hello World!\n");
return 0;

}

#include <stdio.h>

int main(int argc, char *argv[])
{
	printf("%d\n",argc);
	while (argc--)
		printf("%s\n",argv[argc]);

	return 0;
}

int   argc ;
   这个东东用来表示你在命令行下输入命令的时候，一共有多少个参数。比方说你的程序编译后，可执行文件是main.exe ,直接在E盘根目录下面。
   E:\>main
   这个时候，argc的值是1
   但是
E:\>main QING blog 的话，argc的值是3。也就是命令名加上两个参数，一共三个参数

  char   *argv[] ;
   这个东东用来取得你所输入的参数
  E:\>main
   这个时候，argc的值是1，argv[0]的值是   "main"
   E:\>main QING blog
   这个时候，argc的值是3，argc[0]的值是"main"，argc[1]的值是"QING"，argc[2]的值是"blog"。（当然上面的代码为了方便，是逆着输出的）。
   这个东东一般用来为程序提供非常重要的信息，如：数据文件名，等等。

参考文章：Lambol_8309的专栏，http://blog.csdn.net/lambol_8309/article/details/4524964

QlNG

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
拓展题系列I之科普系列

拓展题系列I之科普系列（共10道题目，总分15分，结算时，将你所得的分数换算成5分制，如：得了9分就是3分）：1.编写一段代码，要求输出分别“烫烫烫...”和“屯屯屯...”，并简要说明原因。(2分)2.C++小知识： (1).C++中函数的默认参数. 可以查看： C++ Primer Plus 275页. (2).C++中函数重载.
复制链接

扫一扫