C++實例教學-基礎知識

2019-11-17 05:20:40

字體：大中小

來源：轉載

供稿：網友

　　1.1 簡單的C++程序
// PRogram 1_1.cpp
#include<iostream.h>
void main()
{
cout<<"Let's learn to write a C++ Program.";
cin.get();
}
此程序由6行組成，
1)第1行為注釋，程序的每行如出現符號" // "，則其右的所有符號為注釋。注釋是幫助閱讀程序的說明，與該程序運行沒有關系。在程序被編譯時，注釋被當作空格處理。此行指出本程序以文件"program 1_1.cpp"存儲。
2)第二行#include是一條編譯預處理指令，它告訴編譯系統在編譯本程序時把系統提供的頭文件iostream.h的內容插入到第二行的位置，它在程序中的作用與第5行的輸出語句有關。
3)第3~6行是程序的主體，由一個主函數組成。其中main是主函數名，第一個void指出該函數無返回值。括號()表示函數，括號內為函數的參數表，但此函數無參數，故用void表示，它與空括號的效果相同。
第4~6行稱為函數體，用{ }括起來。函數體內可以包含任意多行語句。
第5行是本程序中唯一要執行的任務：向屏幕輸出(顯示)一字符串。
cout是一個標準輸出文件名，這里表示屏幕。符號“<<”是運算符，它指示計算機把其右端用雙引括起來的字符串輸送到cout文件即屏幕。由于cout和<<的說明都在系統提供的頭文件iostream.h中，因此，凡是程序中需要使用cout、<<等標準輸入輸出功能時，第二行包含的指令#include必須列出。
　　 4) cin.get()表示按任意鍵繼續。
5)此程序的執行結果為在屏幕上顯示：
Let's learn to write a C++ Program.

---------------------------------------

1.1.2 求兩個數的和
程序如下：
// program 1_2.cpp
#include<iostream.h>
void main()
{
int a,b,sum; // 定義了三個整型變量
a=43; // 把整數常量賦給變量a
b=37;
sum=a+b; // a與b相加的和賦給變量sum
cout<<"The sum is"<<sum;
cout<<endl; // endl 是回車換行的作用
}
程序運行結果如下：
This sum is 80

----------------------------

1.1.3 計算圓面積
程序代碼如下：
// program 1_3.cpp
#include<iostream.h>
void main()
{
const float pai=3.14; // 用const 說明了一個float型常量pai,m由于pai是常量，所以在
// 程序中這個值不會被改變
float radius; // 說明了一個float型變量radius，用于存放半徑值
cout<<"Enter radius: ";
cin>>radius; // cin 為iosream.h中說明的文件，作用為接收鍵盤輸入。如此
// 時從鍵盤輸入一個數2.5,就把輸入的這個值送入變量radius.
float area=pai*radius*radius; // 說明了一個float型常量area，用于存放計算后的面積
cout<<"/n The area of circle is : ";
cout<<area<<endl; // 輸出面積
}
程序運行結果如下：
Enter radius: 2.5
The area of circle is 19.625

說明：這個程序相對于progam 1_2有一個明顯的優點，就是它的輸入數據不必在編程時確定，而是在運行時由操作者直接從鍵盤輸入。

--------------------------------------------------------------------------------------

上面的程序稱為簡單程序。直觀上看，它們都很短，進一步分析發現它們有兩個特點：
1)程序要做的事情是由程序員在編程時就安排好了的，是固定不變的。
2)程序要做幾個動作也是由程序員在編程時安排好的，程序實際上是一個簡單的命令序列。

下面的程序有了“判定”的能力。此程序用于溫度值(攝氏與華氏溫度)的換算，輸入溫度值并指出該值是攝氏(C)還是華氏(F)溫度，然后程序根據不同的輸入(攝氏或華氏)進行不同的換算。
2.1 按條件進行判定
// program 2_1.cpp
#include<iostream.h>
void main()
{
float t,tc,tf;
char corf;
const float fac=1.8,inc=32;
cout<<"Enter temperature: ";
cin>>t; // 輸入溫度值
cin>>corf; // 指出是攝氏(C)或華氏(F)
if(corf=='c'corf=='C')
{
tc=t;
tf=t*fac+inc;
}
else
if(corf=='F'corf=='f')
{
tf=t;
tc=(t-inc)/fac;
}
else tc=tf=0.0;
cout<<endl<<"The temperature is: ";
cout<<tc<<"C="<<tf<<"F/n";
}
程序運行結果如下：
Enter temperature: 40.2C
The temperature is 40.2C=104.36F

-----------------------------------

下面是使用switch(開關)語句的程序。switch提供了多分支選擇的方法。

5.2 簡單的計算器程序
這個程序完成的功能是：輸入兩個數，然后輸入運算符，在屏幕上顯示運算結果。
// program 2_2.cpp
程序運行結果如下：
#include<iostream.h>
void main()
{
int x,y;
char op;
cout<<"first integer: ";
cin>>x;
cout<<endl<<"Second integer: ";
cin>>y;
cout<<endl<<"Operator(+,-,*,/,%): ";
cin>>op;
switch(op) // switch 開關分支語句從這里開始，根據表達式的值分支
{
case '+': // 假如 op=='+'
cout<<endl<<x<<"+"<<y<<"="<<x+y;
break; // 執行完畢，退出switch分支。下面的break語句的作用相同
case '-': // 假如op=='-'
cout<<endl<<x<<"-"<<y<<"="<<x-y;
break;
case '*': // 假如op=='*'
cout<<endl<<x<<"*"<<y<<"="<<x*y;
break;
case '/': // 假如op=='/'
cout<<endl<<x<<"/"<<y<<"="<<x/y;
break;
case '%': // 假如op=='%'
cout<<endl<<x<<"%"<<y<<"="<<x%y;
break;
default:
cout<<endl<<"Wrong!";
}
}
程序運行結果如下：
first integer: 12
second integer: 7
operator(+,-,*,/,%): *
12*7 = 84

---------------------------------------

上面的這個程序可以由用戶任意輸入兩個整數及運算符，完成指定的運算，但是它的不便之處是當有多次運算要進行時，每算完一次必須重新啟動程序。下面的程序使用循環控制語句，使得程序可以進行多次運算。
// program 2_5.cpp
#include<iostream.h>
void main()
{
int x,y,quit=1;
char op,cont;
while(quit) // whiel 循環語句，括號里面是一個表達式，稱為控制表達式。當這個表
{ // 達式的值為1時繼續循環體內的代碼。從這個大括號開始，進入循環體。
cin>>x;
cin>>y;
cin>>op;
switch(op)
{
case '+':
cout<<endl<<x<<"+"<<y<<"="<<x+y;
break;
case '-':
cout<<endl<<x<<"-"<<y<<"="<<x-y;
break;
case '*':
cout<<endl<<x<<"*"<<y<<"="<<x*y;
break;
case '/':
if(y==0) cout<<endl<<"Overflow!"; // 判定y是否為0，避免除0錯誤。
else
cout<<endl<<x<<"/"<<y<<"="<<x/y;
break;
case '%':
if(y==0) cout<<endl<<"Overflow!"; // 判定y是否為0，避免除0錯誤。
else cout<<endl<<x<<"%"<<y<<"="<<x%y;
break;
default:
cout<<endl<<"Wrong!";
break;
}
cout<<endl<<"Do you want to continue?(y or n)";
cin>>cont;
if(cont=='n') quit=0; // 當操作者輸入字符'n'時，由于quit被賦值0。
// 當再次檢測while表達式時，由于quit為0，所以退出while循環。
}
}

這個程序所做出的改進是很明顯的，只要在每次完成一次計算后，用戶回答是否繼續時按下'y'鍵(或除'n'之外的任何字符)，就可以連續運行，完成用戶指定的四則運算，直到接收到字母'n'為止。在循環體內必須有改變while表達式值的語句，否則一旦進入死循環就無法跳出，這種情形稱為“死循環”，編程中應注重避免。 2.3 計算e的值和求素數
e是自然對數的底，它和π一樣是數學中最常用的無理數常量。其近似值的計算公式為：
e=1+1/1!+1/2!+1/3!+...+1/(n-1)!+r
當n充分大時，這個公式可以計算任意精度e的近似值。為了保證誤差r<ε，只需1/(n-1)! ( > r) <ε
程序代碼如下：
// program 2_4.cpp
#include<iostream.h>
void main()
{
const double eps=0.1e-10;
int n=1;
float e=1.0,r=1.0;
do // 開始do循環。循環條件由后面的while中的表達式值確定。
{
e+=r;
n++;
r/=n;
}
while(r>eps);
cout<<"The approximate Value of natural logarithm base is: ";
cout<<e<<endl;
}
程序運行結果如下：
The approximate Value of natural logarithm base is: 2.71828

說明：
上面這個程序中使用了do循環，它是循環控制中的一種。循環控制條件放在后面的while表達式中。
-----------------------------------------
下面的程序用來求出1000以內的全部素數。
// program 2_5.cpp
#include<iostream.h>
void main()
{
const int m=1000;
int i,j,isprime;
for(i=2;i<=m;i++) // 這里用到了for循環控制語句。for循環語句有三個表達式
{ // 第一個表達式賦給變量初值，第二個表達式為循環控制條件，
// 第三個表達式為循環變量改變其值
isprime=1;
for(j=i-1;j>1;j--)
if(i%j==0)isprime=0;
if(isprime)cout<<i<<',';
if(i%30==0)cout<<endl;
}
}

說明：
1)當m值比較大時，這個程序計算量是比較大的，事實上這是用來求出小于m的所有素數的最簡單也是最笨的算法。
一種辦法是作下面的改進：
把 for(j=i-1;j>1;j--)改為：
int i1=int(sqrt(i));
for(j=i1;j>1;j--)
為了確定整數i是不是素數，不需要用2,3，。。。，i-1來除它，只需用2,3，。。。，sqrt(i)試除就可以了。
這里sqrt(i)是標準函數，功能是計算平方根，而int()則是把浮點值圍化為整型值。
另一種算法是埃拉脫散(Eratosthenes)篩法，將在以后介紹。

--------------------------------------------------------------------------------------

3.1 統計學生成績
已知n個學生的注冊號和成績，計算他們的平均成績，并列出成績最好的前t名學生的注冊號和分數。
程序代碼如下：
// program 3_1.cpp
#include<iostream.h>
void main()
{
const int n=3;
const int t=n;
int index[n]; // 存放注冊號
float score[n]; // 存放成績
for(int i=0;i<n;i++)
cin>>index[i]>>score[i]; // 從鍵盤輸入數據
float sum=0;
for(i=0;i<n;i++)
sum+=score[i]; // 計算分數總和
cout.precision(2); // 設置輸出精度
cout<<endl<<"Average score:"<<sum/n;
cout.width(28); // 輸出精度
cout<<endl<<" register number score";
for(i=0;i<t;i++) // 選取前t名分數最高的學生，輸出其注冊號和成績
{
float s=score[i];
int j1=i;
for(int j=i+1;j<n;j++)
if(s<score[j])
{
s=score[j];
j1=j;
}
if(j1>i)
{
score[j1]=score[i];
score[i]=s;
j=index[j1];
index[j1]=index[i];
index[i]=j;
}
cout.width(4); // 輸出序號，注冊號和分數
cout<<endl<<i+1;
cout.width(11); // 設置寬度
cout<<index[i];
cout.width(16);
cout.precision(2); // 設置輸出精度
cout<<score[i];
}
cout<<endl;
}
程序運行結果如下：
C++實例教學-基礎知識（圖一）

說明：
cout.precision(2)是一個函數調用語句，函數名是precision。cout說明此函數是一個標準類的一個標準對象cout的函數。所“標準”，即它們所涉及的流(stream)類和對象cout都是由系統已經義好了的。其說明可以在頭文件iostream.h中找到。函數precision要求一個int型參數，該參數指出在后面輸出的浮點數的精度取到小數點后的多少位。
cout.width()是另一個函數的用法。width決定了其后數據輸出的寬度。

-----------------------------------------------------------------------------------

3.2 輸出三角函數表
輸出人0~90度之間每隔15度的正弦、余弦、正切函數值。
程序代碼如下：
// program 3_2.cpp
#include<iostream.h>
#include<math.h>
void main()
{
const float pai=3.1416f;
const int interval=15;
cout.width(10);
cout<<"Angle x";
cout.width(10);
cout<<"sin(x)";
cout.width(10);
cout<<"cos(x)";
cout.width(10);
cout<<"tan(x)";
float arc;
cout.precision(4);
for(int doa=0;doa<=90;doa+=interval)
{
arc=pai*doa/180;
cout<<endl;
cout.width(10);
cout<<doa;
cout.width(10);
cout<<sin(arc);
cout.width(10);
cout<<cos(arc);
cout.width(10);
if(doa==90) cout<<"-";
else cout<<tan(arc);
}
cout<<endl;
}

程序運行結果如下：
C++實例教學-基礎知識（圖二）

說明：
1)本程序中使用了系統提供的標準庫函數sin(),cos(),tan()，它們都在頭文件math.h中說明。因此在3行包含了此文件。
2)由于當doa=90時，其正切函數趨于無窮大，故對它有非凡的處理，否則如按正弦、余弦一樣輸出，當doa變到90時，運行將可能溢出或打印一個超界的大數。

--------------------------------------------------------------------

3.3 Eratosthenes 篩法求素數
在2_3節給出了一個求在一個范圍內的全部素數的程序。下面給出的程序其算法比原來的好。
program3_5是對2~1000的所有素數進行檢測，用小于該數的數試驗，假如都不能除盡，就找到了一個素數。本節的程序也是用來求1000以內的所有素數，但其思想簡單而巧妙。它是把2~1000所有的整數放到一起，首先把2保留，把2的所有素數從中去掉，再保留3，同時刪去所有3的倍數，下一個數是5,7...。好象是一把篩子，把不需要的數逐步篩去，留下的正是所求的數。
程序代碼如下：
// program 3_4.cpp
#include<iostream.h>
#include<iomanip.h>
void main()
{
const int n=1000;
int i=1,j,count=0,sieve[n+1];
for(j=1;j<n;j++)sieve[j]=j; // 把1~n存入sieve[n]
while(i<n+1) // 從while循環開始完成全部素數的產生和輸出。
{
while(sieve[i]==1) i++; // 跳過值為1的分量，表示下一個分量必為一素數
cout<<setw(4)<<sieve[i]; // setw(4)設置以寬度為4的格式輸出數據。setw(4)
// 等價于cout.width(4)
count++;
if(count%15==0)cout<<endl;
for(j=i;j<n+1;j+=i)
sieve[j]=1;
}
}
程序運行結果如下：
C++實例教學-基礎知識（圖三）

在本節以前給出的程序都是由一個函數組成的，實際上，一個真正的C++程序幾乎都包含若干個由用戶自定義的函數。
在下面的幾個程序實例中，都調用了由用戶定義的函數。

4.1 三次方程求根
按照Cardan公式，計算三次方程x3+px+q=0的一個實根的公式為：
C++實例教學-基礎知識（圖四）

在計算實根xr的程序中，把計算一個浮點數的立方根的程序作為一個用戶定義的函數，而在主程序中兩次調用這個函數。
C++實例教學-基礎知識（圖五）

程序代碼如下：
// program 4_1
#include<iostream.h>
#include<math.h>
float cuberoot(float); // 自定義函數的原型
void main()
{
float p,q,xr;
cout<<"Input paramerters p,q:";
cin>>p>>q;
float a=sqrt(q/2*q/2+p/3*p/3*p/3);
xr=cuberoot(-q/2+a)+cuberoot(-q/2-a); // 調用cuberoot函數
cout<<endl<<"The real root of the equation is "<<xr;
}
float cuberoot(float x) // 自定義函數代碼從這里開始
{
float root,croot;
const float eps=1e-6;
croot=x;
do
{
root=croot;
croot=(2*root+x/(root*root))/3;
}
while(abs(croot-root)>eps);
return croot;
}

------------------------------------------------------------------------------------

4.2 四元排序程序
對于任意的四個整數，經過處理，令其按從大到小的順序排序。
// program 4_2.cpp
#include<iostream.h>
void swap(int &,int &); // 自定義函數原型
void main()
{
int a,b,c,d;
cout<<"Input 4 integers: ";
cin>>a>>b>>c>>d;
if(a<b)swap(a,b); // 調用自定義函數 swap()
if(b<c)swap(b,c);
if(c<d) swap(c,d);
if(a<b) swap(a,b);
if(b<c) swap(b,c);
if(a<b) swap(a,b);
cout<<endl<<a<<" "<<b<<" "<<c<<" "<<d;
}
void swap(int &x,int &y) // 自定義函數代碼從這里開始
{
int temp;
temp=x;
x=y;
y=temp;
}
程序運行結果如下：
Input 4 integers: 17 25 8 41
41 25 17 8

說明：
這是一個簡單的程序。函數swap()是void類型，這表明它沒有返回值，所有用戶定義函數都必須指明返回類型，無返回值的函數必須說明為void類型。
函數swpa()有兩個整型參數，在參數表中的符號'&'表明參數x和y是“引用參數”。這與上節中的float x不同，后者稱為賦值參數。引用參數和賦值參數在使用中主要有下面幾點區別：
1)在形參表中增加符號'&'
2)在調用該函數時，引用參數對應的實參必須是指定類型的變量。如調用swap(a,b)中的實參a,b都是整型變量。而在上節中的賦值參數卻是一個表達式，表達式的念是包含了常量、變量和一般的表達式。比如在本例中，寫成swap(a+b,a-c)或swap(41,a*a+d*d)等都是錯誤的。
引用參數和引用調用是C++語言的一種重要功能，假如swap()的兩個參數說明為賦值形參，會出現什么情況？
本例中的排序并不是一個好的方法，實際上，關于排序有很多好的算法可用。

注重：在編程中函數的作用是太重要了，不過，函數有利于編程、用利于程序結構，卻不能提高程序的效率。相反，在函數調用時由于要保留“現場”以備在函數計算完成返回時繼續運行原來的程序。因此，函數的每次調用，系統都要額外在時間和空間上付出一些代價。
為了解決這個問題，C++語言設置了內聯函數“inline",其具體規定是：
1)在函數定義和說明之前增加要害字inline:
inline void swap(int &x,int &y){......}
2)調用內聯函數與調用非內聯函數的調用效果完全相同，不同的是，在對源程序進行編譯時，對于非內聯函數，其程序代碼只有一份，在每個調用語句處，通過轉移控制語句來運行，然后返回。
對于內聯函數處理則不同，它是把函數體的程序代碼放到每個調用該函數的語句處。例如可以把swap()函數說明為內聯的：
inline void swap(int &x,int &y)
{
int temp;
temp=x;
x=y;
y=temp;
}
經過這一改動，主函數仍不變，通過編譯生成的目標程序將使swap()的函數體程序代碼在其中出現6次。
由此，我們可以看出，采用內聯函數一方面在源程序的編寫中仍可因使用函數而使程序簡短清楚，另一方面在執行中又不必付出調用過程的時間和空間代價，唯一的代價是目標程序加長了。
一般說，調用次數不多的函數或函數體規模較大的函數，其調用代價相對可以忽略，不宜采內聯函數。而函數體積短小且又頻繁被調用的函數可以說明為內聯函數。
例如對于更多個整數的排序算法，假如需要調用swap()的話，那么swap()函數應該說明為內聯的。

-----------------------------------------------------------------------------------------

4.3 ”三色冰激淋“程序
這是一個由冰激淋商提出來的問題，有28種顏色的原料，可以組合成多少種三色冰激淋。一種答案是有 19656=28*27*26種，稱為(28,3)的排列數A 3 28 ，它是把同樣三種顏色的不同排列數也計算進來了，另一答案是3276=19656/3!種，稱為(28,4)的組合數。其中28為元素數，3為選擇數。下面的程序對輸入的元素數和選擇數計算相對應的排列數和組合數。
// program 4_3.cpp
#include<iostream.h>
long factorial(int number); // 函數原型，功能計算C(m,n)=A(m,n)/n!
void main()
{
int i,selections,elements;
cout<<"Number of selections: ";
cin>>selections;
cout<<"Out of how many elements: ";
cin>>elements;
double answer=elements;
for(i=1;i<selections;i++) // 計算排列數A(m,n)=m*(m-1)*...*(m-n+1)
answer*=--elements;
cout<<"A("<<elements+selections-1<<","<<selections<<")=";
cout<<answer<<endl;
answer/=factorial(selections); // 調用factorial函數，以完成計算C(m,n)=A(m,n)/n!

cout<<"C("<<elements+selections-1<<","<<selections<<")=";
cout<<answer<<endl;
}
long factorial(int number) // 計算C(m,n)=A(m,n)/n!
{
long value=1;
while(number>1)value*=number--;
return value;
}
程序運行結果如下：
C++實例教學-基礎知識（圖六）

說明：這個程序中很多地方使用了復合運算符，如*=、--、++等，它們的使用有利于使程序簡短、書寫方便，不過應準確把握其應用方法。
*=是賦值符與=與乘法運算符*復合而成，它是一種雙止運算符，a*=b等價于a=a*b，也可以把它看作為a=a*b的簡化寫法。
--和++稱為減量和增量運算符，屬于單目運算符。a--等價于a=a-1，--a也等價于a=a-1，a--與--a的區別只有當與其它運算共同組成表達式時才能顯現出來。例如answer*=--elements是一個”運算“與”乘賦值“組合成的表達式，其運算順序是：
首先完成--elements，即elements=elements-1
然后完成answer*=elements，即answer=answer*elements
設執行之前answer=20,elements=10,則執行answer*=--elements之后，首先令elements=9,然后answer=20*9=180.
再來看一下value*=number--，運算順序為：
首先完成 value*=number即value=value*number,
然后完成 number--.
設執行前value=20,number=10,則執行value*=number--后，首先value=20*10=200，然后number=10-1=9.
由此可以看出--a與a--；++a與a++之間的區別了。
factorial()函數也可以采用遞歸函數的方式設計，即在函數體內又(直接或間接地)調用該函數本身，函數定義如下：
long factorial(int number)
{
if(number<=1)return 1;
else return number*factorial(number-1);
}
這個程序與n!的數學定義式
1 n<=1
n! =
n+(n-1)! n>1
相吻合。
遞歸程序往往使程序思路清楚，易編易讀。

上一篇：C++ 成員函數的特性

下一篇：利用C++ Builder進行精確計時