C++錯題整理

基礎題

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

2. 任意輸入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]<<" ";
}

3. 設計一個程序，定義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;
}

5. 
   （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

6. 
   （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)

7. 定義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語言沒有過程，只有函數！