C++错题整理

于 2020-03-22 22:17:31 发布
阅读量5.2k 收藏 62
点赞数 8
分类专栏： 考研 C++ 文章标签： c++ 开发语言 后端 考研
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Arnold_lee_yc/article/details/105037378
版权
考研 同时被 2 个专栏收录
5 篇文章 11 订阅
订阅专栏
C++
2 篇文章 0 订阅
订阅专栏

文章目录

免费分享超过1000本计算机类电子书，包含编程语言、大数据、机器学习、校招面试经验等

(https://github.com/xiaoleetongxue/csbooks)

基础题

1.不可以作为C++用户标识符的是（）

  • A.Printf
  • B._123
  • C.While
  • D.case

C++大小写敏感; case是关键字

2.下列符号中，不可作为分隔符的是（）

  • A.逗号
  • B.分号
  • C.问号
  • D.英文句号

3.在面向对象语言中可扩充性是关键

4.C++程序的实现经过编辑、编译、运行步骤

5.C++编辑器进行编译的过程可详细的分为三个子过程，分别是预处理过程、编译过程、连接过程。

6.常量3.14的数据类型为double

3.14是double

3.14f是float

3.14L是long double

7.设有定义：char ch; ,以下赋值语句正确的是（）

  • A.char = ‘123’;
  • B.char = ‘\xff’;
  • C.char = ‘\08’;
  • D.char = ‘\\’;

B错：ASCII码范围是1~127，ff是255太大了，且十六进制表示ascii码要求有三位二进制数；

C错：八进制不能出现8

8.英文大写字母B的ASCII码为42H，英文小写字母b的ASCII码为62H

H后缀表示十六进制；大小写字母的ASCII码相差32。 32的十六进制是20

9.已知：int a = 5, b = 6;, 下面表达式中，有二义性的是（）

  • A.a+b>>3
  • B.++a+b++
  • C.b+(a=3)
  • D.(a=3)-a++

a+b>>3不同的编译器效果不同，记住！

10.表达式(-17)%5的值等于表达式(17)%(-5)的值

都是-2

11.下列说法正确的（）

  • A.隐含类型转换可能会损失数据精度
  • B.显式类型转换可能会损失数据精度
  • C.隐含类型转换一定会损失数据精度
  • D.显式类型转换一定会损失数据精度

隐含类型转换：编译器自动完成，低类型转换为高类型，不会损失数据精度

显式类型转换：由用户指定，强制转换，可能出现数据精度损失（int）3.14

12.C++中可以用于浮点数的运算符：++

13.结合性从左到右：==

14.结果是1

#include <iostream>
using namespace std;
int main()
{
	int x, y, z;
	x=y=z=1;
	int t = ++x||++y&&++z;
	cout<<t<<endl;
	return 0;
}

逻辑运算符短路原则，++x 为1 后面的不用算了，整个(++x||++y)就为1，再和后面的算

15.结果为 666

#include <iostream>
using namespace std;
int main()
{
	int a, b, c;
	a=b=c=5;
	b+=++a&&++c>b;
	cout<<a<<b<<c<<endl;
	return 0;
}

相当于b+=( (++a) && (++c>b) ), 先执行等号右边的表达式，等于1，b = b+1

16.在C++中，const修饰符主要用于代替C语言中的#define关键字进行常量定义

17.在32位计算机中，若有double * p;，则p占用4字节的内存空间。

18.空字符串长度为1

空字符串中只有一个\0

19.辗转相除法求整数a、b最小公倍数

#include <iostream>
using namespace std;
int main()
{
	int a, b;
	cin>>a>>b;
	int i=1;
	if(a<b)
	{
		int t = a;
		a = b;
		b = t;
	} 
	while(i*a%b!=0) i++;
	cout<<i*a<<endl;
	return 0;
}

以除数和余数反复做除法运算，当余数为 0 时，取当前算式除数为最大公约数

最小公倍数=两数之积/最大公约数

int main()
{
	int a,b,c,d,e;
	cout<<"请输入两个整数:"<<endl;
	cin>>a>>b;
	d=a;e=b;
	do{
	    c=a%b;
	    a=b;
	    b=c;
	}while(c!=0);
	cout<<"最大公约数是:";
	cout<<a;
	cout<<"最小公倍数是:";
	cout<<d*e/a;
	return 0;
}

20.下列关于函数模板叙述正确的（）

  • A.函数模板实际上是函数类型和形参类型不具体指定的通用函数
  • B.函数模板可以用于描述函数体不同的一系列函数
  • C.函数模板可以用于描述参数个数不同的一系列函数
  • D.函数模板定义中的typename和class的作用不同

C++中typename和class可以替换，引入只是为了避免混淆，作用一样

#include <iostream>
using namespace std;

template <typename T>
T max(T a, T b, T c)
{
    if(b>a) a=b;
    if(c>a) a=c;
    return a;
}

int main()
{

	int x1=1, x2=2, x3=3;
	double d1=1.5, d2=2.5, d3=3.5;
	int rs = max(x1, x2, x3);
	double rs2 = max(d1, d2, d3);
	cout<<rs<<" "<<rs2<<endl;
	return 0;
}

函数模板：重点在模板，专门产生函数的模子；

模板函数：重点在函数，由模子生成而来的函数。

21.下列叙述正确的是（）

  • A.预处理命令行必须位于源文件的开头
  • B.在源文件的一行上可以有多条预处理命令
  • C.宏名必须用大写字母表示
  • D.宏替换不占用程序的运行时间

A错，预处理命令行可以出现在源程序的任何位置上，通常在开头。

B错，源程序的一行上只能出现一条预处理命令。

C错，宏名只要是符合要求的标识符都可以，没有规定一定要大写。

D正确，宏替换在程序编译时，就由编译程序对出现的宏名进行了相应的宏替换，因此宏替换不占用程序的运行时间。

22.关于局部变量说法错误的

  • 函数声明中的形式参数名在函数被调用时分配内存空间

错！函数声明中的形参不起作用；函数定义中的形参才起作用！

23.属于文件及作用域的标识符是

  • 外部静态类标识符

文件作用域
在函数和类之外说明的标识符具有文件作用域，其作用域从说明点开始，在文件结束处结束。

#include <iostream.h>
int i;  //文件作用域
void main()
{
    i＝5;
    {
　　    int i; //块作用域
　　    i=7;
　　    cout << "i=" << i ;// 输出7
    }
    cout<< "i=" << i; //输出5
}

24.作用域运算符的功能是

  • 标识某个成员属于哪个类

25.当函数的自变量个数不确定时，参数表用（）标识

  • A. …
  • B. *
  • C. 空格
  • D. ？
int   printf(   const   char*   format,   ...);

26.说法正确

  • 当函数自变量个数不确定时，系统不自动检测自变量

记住！

27.下列关于用#define定义说法正确的（）

  • 在函数中定义的常量的作用域从定义起到#undef取消为止或文件结束

#define定义预处理器标识符，将保持已定义状态且在作用域内，直到程序结束或者使用#undef 指令取消定义。

28.关于寄存器变量一下说法都是正确的：（记住）

  • 由于受硬件寄存器长度的限制，所以寄存器变量只能是char、int或指针型。
  • 由于register变量使用的是硬件CPU中的寄存器，寄存器变量无地址，所以不能使用取地址运算符"&"求寄存器变量的地址。
  • 寄存器说明符只能用于说明函数中的变量和函数中的形参，因此不允许将外部变量或静态变量说明为"register"。

29.变量默认初始化

  • 静态局部变量，不赋初值，编译时自动赋初值0或空字符
  • 自动变量，不赋初值，它是一个不确定的值
    （每次函数调用结束后存储单元已释放，下次调用时又重新另分配存储单元，而所分配的值不确定）
  • 全局变量自动初始化为0（似乎是这样）

30.预处理命令

  • 预处理命令以符号“#”开头
  • 在编译之前进行的处理
  • C语言的预处理主要有三个方面的内容： 1.宏定义； 2.文件包含； 3.条件编译。
  • 属于编译器的命令，不属于C++语言

31.下列关于内联函数的描述中错误的是（ ）

  • A.内联函数是在程序编译时被执行的
  • B.用inline修饰的函数原型其对应的函数也将成为内联函数
  • C.内联函数不能是递归函数
  • D.内联函数的主要作用是提高程序的运行效率

是否把当前函数作为内联函数并不是关键字就能决定的, 编译器会左右

32.下列程序第几行编译出错

#include<iostream>
#define aa 123;     //虽然有 ; 但是编译能通过
using namespace std;

int main(void)
{
	cout<<aa<<'\n'; //编译出错，aa不是变量，不能被引用
	return 0;
}

33.下列程序运行结果

#include<iostream>
using namespace std;
int a;

int main()
{
	int a(20);  //局部变量1
	{
		int a;  //局部变量2
		a=10;
		::a=5;      //将全局变量a赋值5
		cout<<a<<endl;  // 10
	}
	cout<<a<<endl;  //20
	cout<<::a<<endl;    //5
	return 0;
}

运行结果：

10

20

5

34.数组说法不正确

  • A.数组是数据的集合

数组是有序数据的集合

35.程序结果

#include<iostream>
using namespace std;

int a[10];
int c;  //全局变量默认是0

int main()
{
	int i = 0, j;
	int x;
	while(i<10)
	{
		cin>>x;
		for(j=0;j<c && a[j]!=x;j++);	//j是当前这个数要插入的下标 
		if(j>=c) a[c++]= x;	//c是当前的下标	
		i++;	//循环次数 
	}
	for(i=0;i<c-1;i++)
	for(j=i;j<c;j++)
	if(a[i]<a[j]) 
	{
		x=a[i];a[i]=a[j];a[j]=x;
	}
	for(i=0; i<c; i++)
	cout<<a[i]<<",";
	cout<<endl;
	return 0;
}

75 78 76 75 81 92 60 55 70 78

92,55,60,75,76,78,81,70,

36.程序找错(A)

class CC1
{
    private:
        int a=2;    //A
        CC();   //B
    public:
        CC1(int val);   //C
        ~CC1(); //D
}

数据成员不能在类体内初始化！！！

37.类的指针成员的初始化是通过函数完成的，这个函数通常是（）

  • A.析构函数
  • B.构造函数
  • C.其他成员函数
  • D.友元函数

38.在派生类中重新定义虚函数时，必须在下列哪方面与基类保持一致（）

  • A.参数类型
  • B.参数名称
  • C.操作内容
  • D.赋值

39.在函数调用时，如某一默认参数要指明一个特定值，则有（）

  • A.其之前所有参数都必须赋值
  • B.其后所有参数必须赋值
  • C.其前、后所有参数都必须赋值
  • D.其前、后所有参数都不必赋值

40.this指针存在的目的
保证每个对象拥有自己的数据成员，但共享处理这些数据成员的代码

41.以下赋值正确的语句是()

  • A. p=a;
  • *B. p=a;
  • C. q=a;
  • D. q=*a;
  • E. p=a[0];

指向一维

42.释放动态数组正确的语句**(很重要！！！)**

int *p = new int[10];
  • A. delete [] p;
  • B. delete p[];
  • C. delete int [] p;
  • D. delete p int [10];

43.运算结果

cout<<(3<<3)<<endl;     //24
cout<<(24>>3)<<endl;    // 3
cout<<(2^5)<<endl;  //7

"<<"左移 3的二进制位0000 0011，左移三个单位0001 1000，即24

">>"右移 24的二进制位0001 1000，右移三个单位0000 0011，即3

"^"异或运算， 2的二进制为 0010，5的二进制为0101 结果为 0111,即7

44.const成员函数可以在类的外部初始化(错！)

const成员函数只能通过构造函数的参数初始化表进行初始化

44.函数重载的目的

  • A 实现共享
  • B 使用方便，提高可读性
  • C 提高速度
  • D 减少空间

第一套卷

45.从程序片段

char name[] = "C++";
course(name);

可以判断函数course的调用是采用

  • A 传值调用
  • B 带缺省参数值得函数调用
  • C 引用调用
  • D 传址调用

实参是数组，传递的是第一个元素的首地址，所以是传址调用

46.内存泄漏是指（）

  • A 内存中的数据出现丢失
  • B 试图释放一个已经释放了的动态分配的堆内存
  • C 函数中局部变量所占的占内存没有及时回收
  • D 动态分配的堆内存在程序退出后始终被占用

47.友元函数（）

  • A 可以被声明为const
  • B 没有this指针
  • C 可以用类名或对象名来调用
  • D 只能用对象名来调用

A项错误，记住

C项错误，不能通过类名调用

D项错误，如果友元函数为一般函数，那么可以直接调用！

48.若一个类的成员函数前用static,则该成员函数（）

  • A 可以被声明为const
  • B 没有this指针
  • C 可以访问该类的所有成员
  • D 只能用对象名来调用

A错误，静态成员函数不可以同时声明为 virtual、const、volatile函数

C错误，静态成员函数没有this指针，只能引用静态成员

D错误，可以通过对象名引用，也可以通过类名引用，但最终归属于类

49.程序设计题

1.定义一个商品类CGoods，其中包含商品号(long no)、商品名(char *p_name)、商品价格（double price）三个数据成员，以及相应的构造函数、拷贝构造函数、析构函数、打印数据成员的成员函数

#include<iostream>
#include<string.h>
using namespace std;

class CGoods
{
	protected:
		long no;	//商品号 
		char *p_name;	//商品名 
		double price;	//商品价格 
	
	public:
		CGoods(long n, char *name, double p);	//构造函数 
		CGoods(const CGoods &goods);	//拷贝构造函数 
		~CGoods();	//析构函数 
		void print() const;	//打印成员函数 
};

CGoods::CGoods(long n, char *name, double p)
{
	no = n;
	p_name = new char[strlen(name)+1];
	strcpy(p_name, name);
	price = p;		
}		
CGoods::CGoods(const CGoods &goods)
{
	no = goods.no;
	p_name = new char[strlen(goods.p_name)+1];
	strcpy(p_name, goods.p_name);
	price = goods.price;
}
CGoods::~CGoods()
{
	delete p_name;
}
void CGoods::print() const
{
	cout<<"Goods no: " <<no<<endl;
	cout<<"Goods name: "<<p_name<<endl;
	cout<<"Goods price: "<<price<<endl; 
}

int main()
{
	CGoods g1(1001, "shirt", 100);  //调用构造函数
	g1.print();
	CGoods g2(g1);  //调用拷贝构造函数
	g2.print(); 
	return 0;
}

Goods no: 1001

Goods name: shirt

Goods price: 100

2为CGoods类增加一个商品总数(int count)数据成员，并增加一个成员函数getCount()获取cout的值，编写与一个友元函数getName()获取商品名称p_name。

#include<iostream>
#include<string.h>
using namespace std;

class CGoods
{
	protected:
		long no;	//商品号 
		char *p_name;	//商品名 
		double price;	//商品价格 
		static int count;	//商品总数 
	
	public:
		CGoods(long n, char *name, double p);	//构造函数 
		CGoods(const CGoods &goods);	//拷贝构造函数 
		~CGoods();	//析构函数 
		void print() const;	//打印成员函数 
		static int getCount();	//静态成员函数 
		friend char *getName(CGoods &good);	//友元函数 
};

int CGoods::count = 0;	//初始化静态成员商品总数 

CGoods::CGoods(long n, char *name, double p)
{
	no = n;
	p_name = new char[strlen(name)+1];
	strcpy(p_name, name);
	price = p;
	count++;	
}		
CGoods::CGoods(const CGoods &goods)
{
	no = goods.no;
	p_name = new char[strlen(goods.p_name)+1];
	strcpy(p_name, goods.p_name);
	price = goods.price;
	count++;
}
CGoods::~CGoods()
{
	delete p_name;
	count--;
}
void CGoods::print() const
{
	cout<<"Goods no: " <<no<<endl;
	cout<<"Goods name: "<<p_name<<endl;
	cout<<"Goods price: "<<price<<endl; 
}

int CGoods::getCount()
{
	return count;
} 

char *getName(CGoods &good)
{
	return good.p_name;
}

int main()
{
	CGoods g1(1001, "shirt", 100);
	g1.print();
	CGoods g2(g1);
	g2.print(); 
	cout<<"total count: "<<CGoods::getCount()<<endl;    //调用静态成员函数
	cout<<"name: "<<getName(g2)<<endl;  //调用友元函数
	return 0;
}

Goods no: 1001

Goods name: shirt

Goods price: 100

Goods no: 1001

Goods name: shirt

Goods price: 100

total count: 2

name: shirt

4.以CGoods的类为基类，派生出CClothes和食品类CFood两个派生类，并在这两个勒种分别增加一个表示品牌的指针成员（char *p_brand）和表示用途的成员函数（void usedFor()–可分别输出一条表示服饰和食品用途的信息）。写出CClothes类和CFood类的完整定义（包括构造、析构和usedFor()成员函数的实现）

#include<iostream>
#include<string.h>
using namespace std;

class CGoods
{
	protected:
		long no;	//商品号 
		char *p_name;	//商品名 
		double price;	//商品价格 
		static int count;	//商品总数 
	
	public:
		CGoods(long n, char *name, double p);	//构造函数 
		CGoods(const CGoods &goods);	//拷贝构造函数 
		~CGoods();	//析构函数 
		void print() const;	//打印成员函数 
		static int getCount();	//静态成员函数 
		friend char *getName(CGoods &good);	//友元函数 
};

int CGoods::count = 0;	//初始化静态成员商品总数 

CGoods::CGoods(long n, char *name, double p)
{
	no = n;
	p_name = new char[strlen(name)+1];
	strcpy(p_name, name);
	price = p;
	count++;	
}		
CGoods::CGoods(const CGoods &goods)
{
	no = goods.no;
	p_name = new char[strlen(goods.p_name)+1];
	strcpy(p_name, goods.p_name);
	price = goods.price;
	count++;
}
CGoods::~CGoods()
{
	delete p_name;
	count--;
}
void CGoods::print() const
{
	cout<<"Goods no: " <<no<<endl;
	cout<<"Goods name: "<<p_name<<endl;
	cout<<"Goods price: "<<price<<endl; 
}

int CGoods::getCount()
{
	return count;
} 

char *getName(CGoods &good)
{
	return good.p_name;
}

class CClothes: public CGoods	//派生类 
{
	private:
		char *p_brand;
	public:
		CClothes(long n, char *name, double p, char *brand );
		~CClothes();
		void usedFor(); 
};

CClothes::CClothes(long n, char *name, double p, char *brand):CGoods(n, name, p)
{
	p_brand = new char[strlen(brand)+1];
	strcpy(p_brand, brand);
}

CClothes::~CClothes()
{
	delete p_brand;
}

void CClothes::usedFor()
{
	cout<<"use for wearing"<<endl;
}

class CFood:public CGoods
{
	private:
		char *p_brand;
	public:
		CFood(long n, char *name, double p, char *brand);
		~CFood();
		void usedFor();
};

CFood::CFood(long n, char *name, double p, char *brand):CGoods(n, name, p)
{
	p_brand = new char[strlen(brand)+1];
	strcpy(p_brand, brand);
}

CFood::~CFood()
{
	delete p_brand;
}

void CFood::usedFor()
{
	cout<<"use for eating"<<endl;
}

int main()
{
	CGoods g1(1001, "shirt", 100);
	g1.print();
	CGoods g2(g1);
	g2.print(); 
	cout<<"total count: "<<CGoods::getCount()<<endl;
	cout<<"name: "<<getName(g2)<<endl;
	
	CClothes clothe(1002, "skirt", 20, "zara");
	clothe.usedFor();
	CFood *f = new CFood(1003, "humbarger", 15, "KFC");
	f->usedFor(); 
	cout<<"total count: "<<CGoods::getCount()<<endl;
	delete f; 
	cout<<"total count: "<<CGoods::getCount()<<endl;
	return 0;
}

Goods no: 1001

Goods name: shirt

Goods price: 100

Goods no: 1001

Goods name: shirt

Goods price: 100

total count: 2

name: shirt

use for wearing

use for eating

total count: 4

total count: 3

50.程序设计题

  1. 设计简单的程序，计算表达式根号1+x方/(1+x)
#include <iostream>
#include <math.h>
using namespace std;

int main()
{
	int x;
	double z;
	cout<<"please input enter the number x:"<<endl;
	cin>>x;
	z= sqrt( 1+pow(x, 2)/(1+x) ) ;
	cout<<"The result is: "<<z<<endl;
	return 0;
}

please input the number x:

0

The result is: 1

  1. 任意输入10个整数，并将其按照从大到小的顺序排序输出
//冒泡排序，小数沉底
#include <iostream>
using namespace std;

int main()
{
	int i, j, t, a[10];
	cout<<"please input 10 numbers: "<<endl;
	for(i=0; i<10; i++)
		cin>>a[i];

	for(i=0; i<9; i++)
		for(j=0; j<9-i; j++)
			if(a[j]<a[j+1])
			{
				t = a[j];
				a[j] = a[j+1];
				a[j+1] = t;
			}
	cout<<"The result is: "<<endl;
	for(i=0; i<10; i++)
		cout<<a[i]<<" ";
}

please input 10 numbers:

0 1 2 3 4 5 6 7 8 9

The result is:

9 8 7 6 5 4 3 2 1 0

//选择排序
#include <iostream>
using namespace std;

int main()
{
	int i, j, temp, a[10], max;
	cout<<"please input 10 numbers: "<<endl;
	for(i=0; i<10; i++)
		cin>>a[i];
	
	//选择排序 
	for(i=0; i<9; i++)
	{
		max = i;
		for(j=i+1; j<10; j++)
			if(a[j]>a[max])
				max = j;
		if(max != i)
		{
			temp = a[i];
			a[i] = a[max];
			a[max] = temp;
		}
	}
			
	for(i=0; i<10; i++)
		cout<<a[i]<<" ";
}
  1. 设计一个程序，定义4个函数分别返回两个双精度数的和、差、积、商(注意解决除数为零的情况)
#include <iostream>
using namespace std;

double he(double a, double b){return a+b;}
double cha(double a, double b){return a-b;}
double ji(double a, double b){return a*b;}
double shang(double a, double b){return a/b;} 

int main()
{
	double d1=1, d2=1;
	cout<<"please input 2 number(double): "<<endl;
	cin>>d1>>d2; 
	while(d2 == 0)
	{
		cout<<"除数不能为0，请重新输入："<<endl;
		cin>>d1>>d2; 
	}
	cout<<"和："<<he(d1, d2)<<endl;
	cout<<"差："<<cha(d1, d2)<<endl;
	cout<<"积："<<ji(d1, d2)<<endl;
	cout<<"商："<<shang(d1, d2)<<endl; 
	return 0;	
}

please input 2 number(double):

1 0

除数不能为0，请重新输入：

0 0

除数不能为0，请重新输入：

0 1

和：1

差：-1

积：0

商：0

4.设计一个圆形的类Circle，其私有数据成员（double类型）r为半径；公有成员函数GetL、GetS用于返回其周长及面积；Set函数用于设置r的值；构造函数在没有参数传入时把r的初始值化为0，若有参数传入则按参数数值初始化r的值；试在主函数中创建类Circle的对象，并输出r为3.5是的周长和面积

#include <iostream>
using namespace std;

class Circle
{
	private:
		double r;
	public:
		Circle(double a=0){r=a;}    //注意，这里用的是带默认参数的构造函数
		double GetL(){return 2*3.14*r;}
		double GetS(){return 3.14*r*r;}
		void Set(double a){r=a;}
};

int main()
{
	Circle c;
	c.Set(3.5);
	cout<<"周长："<<c.GetL()<<" "<<"面积："<<c.GetS()<<endl; 
	return 0;
}

  1. （1）月工资计算办法：销售经理固定月薪8000,并提取销售额的 5/1000作为工资；销售员工只有提取销售额的5/1000作为工资。
    （2）基类Employee，包含3个数据成员（number、name、salary），用于输入编号和姓名的构造函数。
    （3）由Employee类派生SalesMan类，SalesMan包含两个新数据成员commrate、sales，还包含用于输入销售额并计算销售员工工资的成员函数pay和用于输出的成员函数print
    （4）由Salesman类派生SalesManager类，包含新数据成员monthlypay，以及用于输出销售额并计算销售经理工资的成员函数pay、用于输出成员函数print()。（5）在main函数中测试，求出不同员工的工资
#include <iostream>
using namespace std;

class Employee
{
	protected:
		long number;
		string name;
		double salary;
	public:
		Employee()
		{
			cout<<"编号：";
			cin>>number;    //在构造函数中输入
			cout<<"姓名：";
			cin>>name;
			salary=0; 
		} 
};

class SalesMan:public Employee
{
	protected:
		double commrate;
		double sales;
	public:
		SalesMan()
		{
			commrate = 0.005;
		}
		void pay()
		{
			cout<<name<<"本月销售额：";
			cin>>sales;
			salary = sales*commrate; 
		}
		void print()
		{
			cout<<"销售员："<<name<<", 编号："<<number<<", 本月工资："<<salary<<endl; 
		}
};

class SalesManager:public SalesMan
{
	private:
		double monthlypay;
	public:
		SalesManager()
		{
			monthlypay = 8000;
			commrate = 0.005;
		}
		void pay()
		{
			cout<<name<<"本月部门销售额：";
			cin>>sales;
			salary = monthlypay+sales*commrate; 
		}
		void print()
		{
			cout<<"销售经理："<<name<<", 编号："<<number<<", 本月工资："<<salary<<endl; 
		}
};

int main()
{
	SalesMan obj1;
	obj1.pay();
	obj1.print();
	SalesManager obj2;
	obj2.pay();
	obj2.print();
	return 0;	
}

编号：1001

姓名：Jack

Jack本月销售额：1000

销售员：Jack, 编号：1001, 本月工资：5

编号：1002

姓名：Peter

Peter本月部门销售额：1000

销售经理：Peter, 编号：1002, 本月工资：8005


  1. （1）定义结构变量Point，直线类Line
    （2）Point中有x,y两个成员，表示横纵坐标
    （3）Line类有两个数据成员a、b,表示y=ax+b的系数，成员函数print用于显示直线方程；友元函数setPoint(Line &l1, Line &l2)用于求两条直线的交点
    （4）在main函数中建立两个直线对象，分别调用print显示两条直线方程，并调用setPoint求着两条直线的交点
#include <iostream>
using namespace std;

struct Point
{
	double x;	//横坐标 
	double y;	//纵坐标 
};

class Line
{
	private:
		double a;	//斜率 
		double b;	//截距
	public:
		Line(double x, double y):a(x),b(y){}
		void print(){cout<<"y="<<a<<"x+"<<b<<endl;}
		friend Point *setPoint(Line &l1, Line &l2);
}; 

Point *setPoint(Line &l1, Line &l2)
{
	Point *p = NULL;
	if(l1.a == l2.a && l1.b!=l2.b) 
	{
		cout<<"无交点"<<endl;
	}else if(l1.a == l2.a && l1.b==l2.b) {
		cout<<"无数点"<<endl;
	}else{
		p = new Point;
		p->x = (l2.b-l1.b)/(l1.a-l2.a);
		p->y = p->x*l1.a+l2.b;
	}
	return p;
}

int main()
{
	Line l1(5, 1), l2(2, 1);
	l1.print();
	l2.print();
	Point *p = setPoint(l1, l2);
	if(p != NULL)
		cout<<"交点为 ("<<p->x<<", "<<p->y<<")"<<endl;
	return 0;
}

y=5x+1

y=2x+1

交点为 (0, 1)

  1. 定义Time类，拥有hours、minutes和seconds作为数据成员的Time类；设计了成员函数将两个Time对象相加（即时间相加），并进行相应的检查，按60进制设计
#include <iostream>
using namespace std;

class Time
{
	private:
		int hours;
		int minutes;
		int seconds;
	public:
		void set_time();
		void add_time(Time &t1, Time &t2);
		void print();
}; 

void Time::set_time()
{
	cout<<"please input time:"<<endl;
	cin>>hours>>minutes>>seconds;
}

void Time::add_time(Time &t1, Time &t2)
{
	hours = t1.hours + t2.hours;
	minutes = t1.minutes + t2.minutes;
	seconds = t1.seconds + t2.seconds;
	int i;
	i = seconds/60;
	seconds%=60;
	minutes+=i;
	i = minutes/60;
	minutes%=60;
	hours+=i;
}

void Time::print()
{
	cout<<hours<<":"<<minutes<<":"<<seconds<<endl;
}

int main()
{
	Time t1, t2, t3;
	t1.set_time();
	t2.set_time();
	t3.add_time(t1, t2);
	t3.print();
	return 0;
}

please input time:

1 49 50

please input time:

1 30 10

3:20:0

51.由C++源程序文件编译而成的目标文件的缺省扩展名为（）

  • A. cpp
  • B. exe
  • C. obj
  • D. lik

52.char *p = "Hello";输出这个字符串的地址值（）

  • A. cout<<*p;
  • B. cout<<p;
  • C. cout<<&p;
  • *D. cout<<(void )p;

A.cout<<*p; //输出第一个字符，也就是H

B.cout<<p; //输出整个字符串，也就是Hello

C.cout<<&p; //输出指针变量的地址,而非字符串地址
D.cout<<(void *)p; //输出字符串首地址, 要加(void *),否则 p会被认为是字符串。原因：运算符重载的匹配规则

53.

在一个类中定义拷贝构造函数的目的，是为了当利用该类的一个对象初始化另一个对象时，能够避免这两个对象的同一指针同时指向同一块的动态存储空间。

54.现定义函数模板，有什么问题？

template<class T> T max(T t1, T t2)
{
    return t1>t2?t1:t2;
}

max(1, 2.6);

答：函数模板要求两个形参的类型一致，不允许一个是int型一个是double类型，需要将函数模板作出修改

#include <iostream>
using namespace std;

template<class T1, class T2> T2 max(T1 t1, T2 t2){
		return t1>t2?t1:t2;
} 

int main()
{
	cout<<max<int, double>(1, 2.6);
	return 0;	
}

55. #include <filename.h>和#include "filename.h"有什么区别?

#include <filename.h>首先从库文件所在目录搜索文件，在从项目当前路径中搜索文件；
#include "filename.h"首先从项目当前路径中搜索文件，再从库文件所在目录搜索文件

56.程序设计

程序用随机函数生成两位数，取M个各不相等的数据，按生成顺序存放在数组a中。最后输出这个20个数，每10个数换一行

#include <iostream>
#include <stdlib.h>
#include<time.h>
using namespace std;

int insert(int ap[], int k, int n);

int main()
{
	const int M = 20;
	int n, i=0;
	int a[M] = {0};	
	srand(time(0));	//根据每次运行的时间初始化随机数发生器 
	while(i<M)
	{
		do{
			n = rand()%100;	//rand() 产生随机数范围0~65536 %100 只取两位数 
		}while(n<10);	//大于10保证是两位数 
		
		if(insert(a, i, n))	
			i++;	//插入后计数加1 （始终比当前数组下标大1） 
	}
	cout<<"生成数组："<<endl;
	for(i=0; i<M; i++)
	{
		cout<<a[i]<<" ";
		if((i+1)%10==0)	//每10个换一行 
			cout<<endl;	
	} 
	return 0;
}

int insert(int ap[], int k, int n)
{
	for(int j=0; j<=k; j++)	
	{
		if(ap[j] == n)	//查找是否有重复的，如果有就break掉，重新生成随机数 
			break;
		if(j==k)	//如果没有相同的，插入新元素 
		{
			ap[j] = n;
			return 1;	//插入成功 
		}
	}
	return 0;	//插入失败 
}

生成数组：

77 27 51 18 62 63 30 65 25 35

98 39 47 83 34 94 95 58 55 59

总结：

  • rand()函数
#include <stdlib.h> //头文件不能少
#include<time.h>

srand(time(0)); //根据每次运行的时间初始化随机数发生器 
rand(); //产生随机数范围0~65536
  • 数组的形参
//都等价
int insert(int ap[], int k, int n);
int insert(int *ap, int k, int n);

57.程序设计，密码

用拼音输入的名字自动生成6位数字串的密码。
规则：
(1)取字母串的最后6位逆序
(2)每个字母小写的ASCII码值，其除以10的余数为该位的密码值。
(3)当输入名字的字母串不足6位，生成时以字母"z"补足

#include <iostream>
using namespace std;

struct Link
{
	char c;	//字符
	Link *next;	//指针 
};

void inputName(Link *&head);
void getCode(Link *&head, Link *name);
void outLink(Link *link);

int main()
{
	Link *name=NULL, *code=NULL;	//初始化姓名链表、密码链表 
	cout<<"请输入姓名拼音，以#结束："<<endl;
	inputName(name);
	getCode(code, name); 
	cout<<"生成密码为："<<endl;
	outLink(code);
	return 0;
}

void inputName(Link *&head)	//逆序存储 初始head是NULL 
{
	Link *p = new Link;
	p->next = NULL;
	cin>>p->c;
	while( (p->c >= 'a' && p->c <= 'z' || p->c >= 'A' && p->c <= 'Z') && p->c !='#' )	//姓名输入没结束
	{
		p->next = head;
		head = p;
		p = new Link;
		cin>>p->c;
	} 
}

void getCode(Link *&head, Link *name)	//正序存储 
{
	head = new Link;
	head->next = NULL;
	Link *p = head;
	char c = name->c; 
	for(int i=0; i<6; i++)
	{
		p->c = (tolower(c))%10+'0';
		p->next = new Link;
		p = p->next;	//p指针往后移动 
		p->c = '#';
		p->next = NULL;
		if(name->next)
		{
			name=name->next;
			c = name->c;
		}else{
			c = 'z';
		}
	}
} 

void outLink(Link *link)
{
	while(link)	//Link 不为空就输出 
	{
		cout<<link->c;
		link = link->next;
	}
}

请输入名字拼音，以#结束:

ZhangFuwa#

生成密码为：

797230#

总结：

1.为什么形式参数用Link *&head不用Link *head
答：因为函数参数是单向值传递；而在调用该函数前，链表head不存在，只有在调用该函数后，通过参数传递创建单链表head，所以必须传递指针参数*head的地址，所以必须加上*&引用*。在后面编写修改链表（如插入，删除等）时就不需要加&引用了，因为链表已经存在
2.正序 and 逆序单链表？
一个往前插入，一个往后插入

58.写出两个表示数组a最后元素地址值得表达式

int a[20];

cout << &a[19];
cout << a+19;

59.typedef定义函数，三种调用

#include <iostream>
using namespace std;

typedef void (*funType)(int, double);	//定义了新类型funType, 他是一个指向函数的指针 

void function(int a, double b)	//具体函数 
{
	cout<<a<<" "<<b<<endl;;
}

int main()
{
	funType fp;	//funType类的对象fp 
	int a = 1;
	double x = 0.5;
	fp = function;	//fp指向一个具体函数 
	
	function(a, x);	//方式以一： 直接用函数调用 
	fp(a, x);	//方式二：用新对象调用 
	(*fp)(a, x);	//方式三：因为是函数指针，以函数指针的形式调用 
	
	return 0;
}

第二套卷

60.下列语句正确的是（）

  • A. char *s; *s = “abcdefg”;
  • B. char *s; cin>>s;
  • C. char *s1 = “abcd”, *s2 = “efghijk”; strcpy(s1, s2);
  • D. char *s = “abcdefg”; cout<<*s;
    解析：
char *s;
*s = "abcdefg";
/*
    A错在声明字符指针's'时没有分配存储空间，并且*s的值是一个字符，而不是字符串
*/

char *s;
cin>>s;
/*
    B错声明字符指针's'时没有分配存储空间；
    应改为：
    char *s = new char;
    cin>>s;
*/

char *s1 = "abcd", *s2 = "efghijk"; 
strcpy(s1, s2);

/*
    C错在strcpy函数的使用，strcpy第一个参数一定要是字符数组，第二个参数可以是数组也可以是字符常量；毕竟常量是不可以改变的
*/

char *s = "abcdefg"; 
cout<<*s;   //输出第一个字符a

61.已知char *s="abcde;则sizeof(s), sizeof(*s), strlen(s)分别是多少

  • A. 6 1 5
  • B. 4 1 5
  • C. 6 5 4
  • D. 4 4 5
sizeof(s);  //是字符指针的存储空间大小；Visual C++ 对指针变量分配4个字节空间
sizeof(*s); //是字符串首字符的存储空间大小；一个字符占1个字节
strlen(s);  //字符串长度，不算\0，共5个

62.关于拷贝构造函数的描述正确的是（）

  • A.通常的拷贝构造函数的参数是对象的指针类型
  • B.如果不自定义拷贝构造函数，系统提供默认的拷贝构造函数
  • C.如果有自定义的构造函数，系统就不再提供拷贝构造函数
  • D.如果需要用已有对象为新创建的对象初始化时，就必须自定义拷贝构造函数

A项，一般为对象的引用
C项，系统默认提供一个拷贝构造函数
D项，用已有对象给新创建的对象初始化是对象赋值，用已有对象新创建一个对象时对象复制

63.一个类的友元函数或友元类能够通过成员访问运算符访问该类的()

  • A.所有成员
  • B.私有成员
  • C.保护成员
  • D.公有成员

细心！！！，A项包含了其他，不要只盯着私有成员看

64.下列关于getline()函数叙述错误的是（）

  • A.getline()函数仅用于从键盘而不能从文件读取字符串
  • B.getline()函数读取字符串长度是受限制的
  • C.getline()函数读取字符串时，遇到终止符就停止
  • D.getline()函数中所使用的终止符默认是换行符，也可以是其他终止符

65.打开文件的方式中，（）是以追加的方式打开的

  • A.ios::in
  • B.ios::out
  • C.ios::app
  • D.ios::trunc

66.当使用ofstream流类定义一个流对象并打开一个磁盘文件时，文件的隐含打开方式为（）

  • A.ios::out | ios::binary
  • B.ios::in | ios::binary
  • C.ios::out
  • D.ios::in

67.有关函数模板和模板函数说法错误的是（）

  • A.函数模板只是对函数的描述，编译器不为其产生任何执行代码，所以它不是一个实实在在的函数
  • B.模板函数是实实在在的函数，它由编译系统在遇到具体函数调用时所生成，并调用执行
  • C.函数模板需要实例化为模板函数后才能执行
  • D.当函数模板和一般函数同名时，系统先去匹配函数模板，将其实例化后进行调用

函数模板与同名的非模板函数重载时候，调用顺序：

1.寻找一个参数完全匹配的函数，如果找到了就调用它

2.寻找一个函数模板，将其实例化，产生一个匹配的模板函数，若找到了，就调用它

3.若1,2都失败，再试一试低一级的对函数的重载方法，例如通过类型转换可产生参数匹配等，若找到了，就调用它

4.若1,2,3均未找到匹配的函数，则是一个错误的调用

68.判断正误

（1）拥有纯虚函数的类被称为虚拟基类，它不能用来定义对象

错！拥有纯虚函数的类被称为抽象类，它不能用来定义对象

（2）虚函数只有在由继承的情况时才会存在

正确

（3）基类的指针或引用调用虚函数时采用后期绑定

正确，运行时才知道调用谁

第三套题

69.判断下面程序输出的结果(注意！！！)

#include <iostream>
using namespace std;

template<class T>
T max1(T m1 , T m2)
{
	return (m1>m2)?m1:m2;
}

int main()
{
	cout<<max1(1, 7)<<"\t"<<max1(2.0, 5.0)<<endl;
	cout<<max('y', 'b')<<"\t"<<max('A', 'a')<<endl;
	return 0;
}

7 5

y a

注意！！！！， 如果是5.0、2.0这样的数无论函数输出类型是什么，都是5；
但5.6、2.6如果函数返回值类型为double那么就是5.6、2.5

70.在C++中，声明布尔类型变量所用的关键字是bool

71.在使用string类的find成员函数来检索主串中是否含有指定的子串时，若在主串中不含指定的子串，find函数返回值为-1

72.对象传递的消息一般由3部分组成，接收对象名，调用操作名和必要参数

第四套卷

73.在C++中，关于下列函数参数的描述中，正确的是（）

  • A.C++语言中，实参是按照自左至右的顺序求值得
  • B.若一个参数设置了默认值，则其右边的所有参数都具有默认值
  • C.函数参数的默认值不允许是表达式
  • D.设置参数默认值时，应该全部参数都设置

A项，C++的实参是从右至左的顺序求的

B项，默认值得设置应该从右往左

C项，可以是表达式下面举例：

int Max(int m, int n);
int a, b;
void Function2(int x, int y=Max(a,b), int z=a*b){   //默认参数是个表达式
    //...
}

第五套卷

74.以下标识符中不全是保留字的是（）

  • A. case for int
  • B. default then while
  • C. bool class long
  • D. goto return char

C++ 关键字

asm do  if  return  typedef auto    double  inline  short   typeid
bool    dynamic_cast    int signed  typename    break   else    long
sizeof  union   case    enum    mutable static  unsigned    catch
explicit    namespace   static_cast using   char    export  new
struct  virtual class   extern  operator    switch  void
const   false   private template    volatile    const_cast
float   protected   this    wchar_t continue    for
public  throw   while   default friend  register    true
delete  goto    reinterpret_cast    try

75.C++程序的基本单位（）

  • A. 字符
  • B. 语句
  • C. 函数
  • D. 源程序文件

76.假如在程序中a、b、c均被定义成整型，所赋的值都大于1，则下列能正确表示1/abc的表达式是（）

  • A. 1.0/a*b*c
  • B. 1/(a*b*c)
  • C. 1/a/b/(float)c
  • D. 1.0/a/b/c

A: */运算符同级，从左往右，结果不对
B: 都是int结果会省略小数，造成偏差
C: 同B，偏差
D: 正确

77.假定下列x和y均为int型变量，则不正确的赋值（）

  • A. x+=y++
  • B. x++=y++
  • C. x=++y
  • D. ++x=++y

x++不能作为左值！！，++x可以

78.下列的符号常量定义中，错误的是（）

  • A. const M = 10;
  • B. const int M = 20;
  • C. const char ch;
  • D. const bool mark = true;

const 常量必须初始化，但是可以缺省类型，默认为int型

79.下列有语法错误的（）

  • A. int a[] = {1, 2, 3};
  • B. int a[10] = {0};
  • C. int a[];
  • D. int a[5];

C错误，不能既不复制也不指定数组长度

80.关于用户定义库函数

用户可以重新定义标准库函数，若如此，该函数将失去原有含义

81.C++语言的编译系统对宏命令的处理是

  • A. 在程序运行时进行
  • B. 在程序连接时进行
  • C. 和C++程序的其他语句同时进行编译
  • D. 在对源程序中其他成分正式编译之前进行

预编译处理

82.文件包含命令中被包含的文件的扩展名（）

  • A 必须是.h
  • B 不能是.h
  • C 可以是.h 或 .cpp
  • D 必须是 .cpp

83.结构体赋值

#include <iostream>
using namespace std;

struct Book
{
	char title[40];
	float price;	
} x1 = {"C++dfdf", 29.0};   //正确

int main()
{
	Book x = {"C++dfdf", 27.0}; //正确
	cout<<x1.price<<endl;
	return 0;
}

84.在多文件结构的程序中，通常把类中所有非内联函数的定义单独存放在（）中

-A 主文件
-B 实现文件
-C 库文件
-D 头文件

85.假定AA是个类，abc是该类的一个成员函数，则参数表中隐含的第一个参数为（）

-A abc
-B *this
-C this
-D this&

问的是参数名，不是参数类型

86.假定AB为一个类，则执行AB r1 = r2;语句是将自动调用该类的（）

  • A 无参构造函数
  • B 带参构造函数
  • C 赋值重载函数
  • D 拷贝构造函数

AB r1 = r2; 原来没有r1对象，现在从无到有建立一个，并用r2的值赋给r1

87.对类对象成员的初始化是通过构造函数中给出的（）实现的

  • A 函数体
  • B 初始化表
  • C 参数表
  • D 初始化表和函数体

88.对类中引用成员的初始化时通过构造函数中给出的（）实现的

  • A 函数体
  • B 参数表
  • C 初始化表
  • D 初始化表或函数体

89.如果表达式a++的“++”是作为普通函数重载的运算符，若采用运算符函数调用的格式，可表示为（）

  • A a.operator++()
  • B operator++(a)
  • C operator++(a, 1)
  • D operator++(1, a)

C++约定，如果是后置自增自减，运算符重载函数最后一个参数是int，只作为标识，实际上不用

90.在定义一个派生类时，若不使用保留字显式的规定采取何种继承方式，则默认为（）方式

  • A. 私有继承
  • B. 非私有继承
  • C. 保护继承
  • D. 公有继承

默认是private继承！！！！

91.关于插入运算符<<的重载，下列说法不正确的是()

  • A 运算符函数的返回值类型是ostream &
  • B 重载运算符必须定义为类的成员函数
  • C 运算符函数的第一个参数的类型是ostream &
  • D 运算符函数有两个参数

<< >> 必须要用友元函数重载，因为他们的函数第一个参数要求流对象，这一点如果重载为成员函数不能满足要求，所以只能用友元函数重载

92.最符合+ - 原来含义的重载运算符函数（）

// + - 原来的含义只要返回值就行，不用返回对象
Value operator+(Value, Value);
Value Value::operator-(Value);

93.假定K是一个是一个类名，并有定义K k; int j;，已知K中重载了操作运算符(), 且语句j=k(3);和k(5)=9;都能顺利执行，说明该操作符函数的原型只可能是（）

  • A K operator()(int);
  • B int operator()(int &);
  • C int & operator()(int);
  • D K & operator()(int);

j=k(3) k(5)=9 都可以，说明可以做左值，那么函数一定返回的是引用; 又因为j = k(3)，所以一定是int类型。

94.在析构函数中调用虚函数时，采用动态束定？

错X !!!构造函数和析构函数调用虚函数时都不使用动态联编，如果在构造函数或析构函数中调用虚函数，则运行的是为构造函数或析构函数自身类型定义的版本。

第六套卷

95. 友元函数（）

  • A.可以被声明为const
  • B.没有this指针
  • C.可以用类名或对象名来调用
  • D.只能用对象名来调用

可以不通过类名和对象名，直接调用友元函数

96.关于面向对象的程序设计方法，下列说法正确的是（）

  • A. “封装性”指的是将不同类型的相关数据组合在一起，作为一个整体进行处理
  • B. “多态性”指的是对象的状态会根据运行时的要求自动变化
  • C. 基类的私有成员在派生类的对象中不可访问，也不占用内存空间
  • D. 在面向对象的程序设计中，结构化设计方法仍有着重要作用

封装性：指的是将数据和算法捆绑成一个整体，而不是将不同类型的相关数据组合在一起。
多态性：是指一个面向对象的系统常常要求一组具有相同基本语义的方法能在同一接口下为不同对象服务。
私有成员在派生类的对象中不可访问，但是也占据内存空间

97.已知程序中已经定义了函数test,其原型是int test(int, int, int);，则下列重载形式中，正确的是()

  • A.char test(int, int, int);
  • B.double test(int, int, double);
  • C.int test(int, int, int=0);
  • D.float test(int, int, float=3.5f)

一个函数不能既作为重载函数，又作为默认参数的函数

98.下列关于动态存储分配，下列说法正确的是（）

  • A.new和delete是C++语言中专门用于动态内存分配和释放的函数
  • B.动态分配的内存空间也可以被初始化
  • C.当系统内存不够是，会自动回收不再使用的内存单元，因此程序中不必用delete释放内存空间
  • D.当动态分配内存失败时，系统会立刻崩溃，因此一定要慎用new

A错，new和delete是用于动态平衡和释放空间的运算符，不是函数

B正确，int *p = new int(5);

C错，用使用delete释放空间，系统会统一管理，而不用delete释放的空间，会造成内存泄漏，这种程序用的次数过多，会造成内存耗尽

D错，不成功，返回0。

99.以下程序中MyClass类的拷贝构造函数被调用的次数（）

#include<iostream>
class MyClass
{
    public:
        MyClass(int n){number = n;}
        MyClass(MyClass &other){number = other.number;} //拷贝构造函数
        ~MyClass(){}
    private:
        int number;
};
MyClass fun(MyClass p)  //虚实结合调用第2次
{
    MyClass temp(p);    //调用第3次
    return temp;
}
int main()
{
    MyClass obj1(10), obj2(0);
    MyClass obj3(obj1);     //调用第1次
    obj2 = fun(obj3);   //返回值调用第4次
    return 0;
}
  • A.5
  • B.4
  • C.3
  • D.2

100.当使用ofstream流类定义一个流对象并打开一个磁盘文件时，文件的隐含打开方式为（）

  • A.ios::in|ios::app
  • B.ios::out|ios::trunc
  • C.ios::in|ios::out
  • D.没有

101.当使用fstream流类定义一个流对象并打开一个磁盘文件时，文件的隐含打开方式为（）

C++中没有规定文件打开时的隐含打开方式，因此写程序时必须指定打开方式，否则将出现错误。

真题

2011年

102.编写一个翻转字符串的函数

//注意char *的使用
case1:
char *a = "Hello"; 
fun(a)  // 在fun中a的内容不允许改变，因为a是指向一个字符串常量

case2:
char str[20];
char *a = str;
fun(a); //在fun中a的内容可以改变，因为a指向的是字符数组（变量）


#include <iostream>
#include <string.h>
using namespace std;

char * reverse(char *str)
{
	int size = 0, i=0;
	char temp;	//交换时的中间变量 
	size = strlen(str);	//字符串的长度，不包含\0 
	for(i=0; i<size/2; i++)
	{
		temp = *(str+i);
		*(str+i) = *(str+size-i-1);	//下标从0开始，要多减去1 
		*(str+size-i-1) = temp;
	}
	return str;
}

int main()
{
	char s[20];
	char *str = s; 
	cin>>str;
	str = reverse(str);
	cout<<str;
	return 0;
}

#include<iostream>
#include<string.h>
using namespace std;

void reverse(char *str) //这个方法真的棒！
{
	char *pStart = str; //指向头
	char *pEnd = str+strlen(str)-1; //指向尾
	char temp;  //交换用的变量
	while(pStart < pEnd)
	{
		temp = *pStart;
		*pStart = *pEnd;
		*pEnd = temp;
		pStart++;
		pEnd--; 
	}
}

int main()
{
	char a[20];
	char *str = a;
	cin>>str;
	reverse(str);
	cout<<str;
	return 0;
}

103.sizeof

#include<iostream>
using namespace std;

void fun(char str[100])
{
	cout<<sizeof(str);  //形参指针的大小，不是实参32位就是4；64为就是8
}

int main()
{
	char str[] = "111";
	char *p = str;
	cout<<sizeof(str)<<endl;    //字符串str的长度包括\0
	cout<<sizeof(p)<<endl;  //指针的大小，32位就是4；64为就是8
	fun(str);
	return 0;	
}

4

8

8

104.程序找错误

#include<iostream>
using namespace std;

char *GetMemory(void)   //形参为空，无法和主调函数沟通数据，函数结束时，p就被释放掉了
{
	char p[] = "Helloworld";
	return p;   
}

int main()
{
	char *str =NULL;
	str = GetMemory();  //str拿不到数据，仍为空
	cout<<str;
	return 0;	
}

105.输出1到100素数，使用函数，函数声明为int isprime(int)

判断a是不是素数，让a被2~根号a之间(包含)数除，能除尽就不是素数！！

#include<iostream>
#include<cmath>
using namespace std;

int main()
{
	int isprime(int);
	for(int i=1; i<100; i++)
	{
		int flag = isprime(i);
		if(flag==1)
			cout<<i<<" ";
	}	
	return 0;
}

int isprime(int a)
{
	int m = sqrt(a);    //开方
	for(int i=2; i<=m; i++)
		if(a%m==0)
			return 0;
	return 1;
}

2012年

106.设整形变量a、b的值分别为2,3，当执行运算b+=(++a)+(++a)后，b的值

答案为9。 b+=3+3; b=3+3+3=9

2014年

107.下列叙述正确的是（）

  • A.C语言编译时不检查语法
  • B.C语言的子程序有过程和程序两种
  • C.C语言的函数可以嵌套定义
  • D.C语言的所有函数都是外部函数

C语言没有过程，只有函数！

免费分享超过1000本计算机类电子书，包含编程语言、大数据、机器学习、校招面试经验等

(https://github.com/xiaoleetongxue/csbooks)

更多考研资料、调剂技巧可以关注我的公众号，也可以加我的微信
在这里插入图片描述

李润泽
关注
  • 8
    点赞
  • 踩
  • 62
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值