| 程序2-1： |
| |
1．//simple.cpp是一個簡單的C++程序
2．#include <iostream.h>
3．void main(void)
4．{
5. int i;
6． cout<<"Hello C++!";
7． cout<<"請輸入一個整數(shù)：\n";
8． cin>>i;
9． cout<<"您輸入的整數(shù)是：";
10． cout <<i;
11． cout <<'\n';
12．}
|
 |
我們對這個程序逐行加以解釋：
?。?）第一行是C++語言的注釋。其中，"http://"是C++語言的一種注釋符號，自"http://"開始，一直到本行結束，所有內容都會被當作注釋對待。C++注釋也可以寫成下面的形式：
/*注釋內容*/
即夾在"/*"與"*/"號間的部分是要注釋的內容，例如，本句可以改為：
/*simple.cpp是一個簡單的C++程序*/
我們進行程序設計時，這兩種注釋形式都會經常用到。它們的區(qū)別在于：前者只能注釋一行內容，而后者可以注釋多行內容。它可以用在程序的任何地方，編譯器在編譯時將這些信息忽略，注釋就是用來幫助閱讀和理解程序的信息，也可使用注釋來幫助用戶調試程序。
?。?）第2行使用預處理指令#include將頭文件iostream.h包含到程序中來， iostream.h是標準的C++頭文件，它包含了輸入和輸出的定義。
（3）第3行定義了一個稱為main的函數(shù)。
◇ 一個函數(shù)有0個或多個參數(shù)，它們出現(xiàn)在函數(shù)名后的一對圓括號中。
◇ 括號中的void表示main沒有參數(shù)。
◇ 一個函數(shù)可以有一個返回類型，它在函數(shù)名的左邊。
◇ main函數(shù)左邊的返回類型為void，表示沒有返回值。
◇ C++程序的執(zhí)行總是從main函數(shù)開始的。
?。?）第4行是一個花括號，是main函數(shù)體開始的標記。
?。?）第5行是一個語句。
◇ 一個語句可能是定義或聲明一個變量，也可能是得到一個數(shù)值的計算步驟。
◇ 一個語句用分號(;)結尾，C/C++用分號來分隔語句。
◇ 這個語句定義了一個整型變量i。
◇ 一個變量能夠保存一種特定類型的數(shù)據(jù)，整型變量能夠保存一個整型數(shù)據(jù)。
?。?）第6行也是一個語句。
◇ 這個語句將字符串"Hello C++!"發(fā)送到cout輸出流。
◇ 一個字符串是一個用雙引號包圍的字符系列。
?。?）第7行也是一個語句。
◇ 這個語句將字符串"請輸入一個整數(shù)："發(fā)送到cout輸出流。
◇ 字符串的最后一個字符（\n）是一個換行符。
◇ 流是執(zhí)行輸入和輸出的對象。
◇ cout是C++標準的輸出流，標準輸出通常是指計算機屏幕。
◇ 符號<<是一個輸出運算符，帶一個輸出流作為它的左操作數(shù)，一個表達式作為它的右操作數(shù)。后者被發(fā)送到前者，字符串"請輸入一個整數(shù)：\n"發(fā)送到cout的效果是把字符串打印到計算機屏幕上。
（8）第8行也是一個語句。
◇ 這個語句將cin輸入流抽取到變量i。
◇ cin是C++標準的輸入流，標準輸入通常是指計算機鍵盤。
◇ 符號>>是一個輸入運算符，帶一個輸入流作為它的左操作數(shù)，一個變量作為它的右操作數(shù)。前者被抽取到后者，cin輸入流抽取到變量i的效果是將鍵盤的輸入值復制到變量i中。
（9）第9、10、11行分別是在屏幕上打印"您輸入的整數(shù)是："、變量i和和換行符。這三行實際上可以綜合為一個語句：
cout<<"您輸入的整數(shù)是：" <<i <<'\n';
它的效果與使用三個語句是一樣的。
?。?0）第12行的花括號是main函數(shù)體結束的標記。
運用第一章介紹的知識，我們在Visual C++6的開發(fā)環(huán)境里，編譯、連接、運行該程序，可以得到下面的提示：
Hello C++!請輸入一個整數(shù)：
假定我們輸入整數(shù)5，即：
5↙
↙表示鍵入了"ENTER"鍵（或稱為回車鍵），則得到運行結果：
您輸入的整數(shù)是：5
通過這個實例，我們對C++程序的結構、語句、變量、函數(shù)、預處理指令、輸入和輸出等，已有了一個初步的印象，在后面的章節(jié)中，我們還將作更詳細的介紹。
由于我們定義main( )函數(shù)的返回類型為void，所以最后就不用返回值了。如果我們定義main的返回類型的int，則要返回一個整型值：
int main()
{
…
return 0;
}
要注意的是C/C++是區(qū)分大小寫的，不能隨便更改，cout是C++標準的輸出流，而Cout不是，如果沒有預先定義，編譯器就不認識這個Cout。大多數(shù)C＋＋命令使用小寫字母，大多數(shù)常量使用大寫字母，而大多數(shù)變量是大小寫混合使用。
|
|
表2-2 C++關鍵字 |
| |
| asm |
default |
float |
operator |
static_cast |
union |
| auto |
delete |
for |
private |
struct |
unsigned |
| bool |
do |
friend |
protected |
switch |
using |
| break |
double |
goto |
public |
template |
virtual |
| case |
dynamic_cast |
if |
register |
this |
void |
| catch |
else |
inline |
reinterpret_cast |
throw |
volatile |
| char |
enum |
int |
return |
true |
wchar_t |
| class |
explicit |
long |
short |
try |
while |
| const |
export |
mutable |
signed |
typedef |
. |
| const_cast |
extern |
namespace |
sizeof |
typeid |
. . |
| Continue |
false |
new |
static |
typename |
. . |
|
|
|
|
 |
表2-3 基本的數(shù)據(jù)類型及其表示范圍 |
| |
| 類型名 |
類型 |
字節(jié) |
表示范圍 |
| char |
字符型 |
1 |
-128 ~127 |
| unsigned char |
無符號字符型 |
1 |
0 ~255 |
| signed char |
有符號字符型（與字符型相同） |
1 |
-128 ~127 |
| int |
整型 |
* |
與機器有關 |
| unsigned int |
無符號整型 |
* |
與機器有關 |
| signed int |
有符號整型（與整型相同） |
* |
與機器有關 |
| short int |
短整型 |
2 |
-32,768~ 32,767 |
| unsigned short int |
無符號短整型 |
2 |
0~65,535 |
| signed short int |
有符號短整型（與短整型相同） |
2 |
-32,768~ 32,767 |
| long int |
長整型 |
4 |
-2,147,483,648 ~2,147,483,647 |
| signed long int |
有符號長整型（與長整型相同） |
4 |
-2,147,483,648 ~ 2,147,483,647 |
| unsigned long int |
無符號長整型 |
4 |
0~4,294,967,295 |
| float |
浮點型 |
4 |
3.4E +/- 38 (7位有效數(shù)字) |
| double |
雙精度型 |
8 |
1.7E +/- 308 (15位有效數(shù)字) |
| long double |
長雙精度型 |
10 |
1.2E +/- 4932 (19位有效數(shù)字)
|
|
|
|
如果一個雙目運算符兩邊的操作數(shù)類型不同，先要將它們轉換為相同的類型，即較低類型轉換為較高類型，然后再參加運算。所謂類型的高低，跟所占的存儲空間大小有直接關系，所占存儲空間越大的類型，級別越高。
圖中橫向的箭頭表示必須的轉換，如兩個float型數(shù)參加運算，雖然它們類型相同，但仍要先轉換成double型再進行運算，結果亦為double型?？v向箭頭表示當運算符兩邊的操作數(shù)為不同類型時的轉換，如一個long型數(shù)據(jù)與一個int型數(shù)據(jù)一起運算，需要先將int型數(shù)據(jù)轉換為long型，然后兩者再進行運算，結果為long型。所有這些轉換都是由系統(tǒng)自動進行的，使用時只需了解結果的類型即可。
 |
|
程序2-2 |
| |
#include <iostream.h>
void main(void)
{
char a = 'x';
int b = 3,f = 2;
float c = 2.5678;
double d = 5.2345
long e = 32L;
cout<<a - b + d / c - e * f<<endl;
} |
|
下面我們來分析一下這段程序：
?。?） 進行d / c運算時，要將c轉換成double型，運算的中間結果為double型；
?。?） 進行e * f運算時，將f轉換為long型，運算的中間結果為long型；
（3） 進行a - b運算時，將a轉換為int型（數(shù)值為ASCⅡ碼值120），運算的中間結果為int型；
?。?） 當（3）的中間結果與（1）的中間結果運算時，將（3）的中間結果轉換為double型，運算的中間結果為double型；
?。?） 當（4）的中間結果與（2）的中間結果運算時，將（2）的中間結果轉換為double型，得出最后結果。
于是，程序最后的運行結果為55.038515。
|
|
表2-4 |
| |
| 從 |
到 |
方法 |
| char |
short |
符號位擴展 |
| char |
long |
符號位擴展 |
| char |
unsigned char |
最高位失去符號位意義，變?yōu)閿?shù)據(jù)位 |
| char |
unsigned short |
符號位擴展到short;然后從short轉到 unsigned short |
| char |
unsigned long |
符號位擴展到long; 然后從long 轉到unsigned long |
| char |
float |
符號位擴展到long; 然后從long 轉到float |
| char |
double |
符號位擴展到long; 然后從long 轉到double |
| char |
long double |
符號位擴展到long; 然后從long 轉到long double |
| short |
char |
保留低位字節(jié) |
| short |
long |
符號位擴展 |
| short |
unsigned char |
保留低位字節(jié) |
| short |
unsigned short |
最高位失去符號位意義，變?yōu)閿?shù)據(jù)位 |
| short |
unsigned long |
符號位擴展到long; 然后從long轉到unsigned double |
| short |
float |
符號位擴展到long; 然后從long 轉到float |
| short |
double |
符號位擴展到long; 然后從long 轉到double |
| short |
long double |
符號位擴展到long; 然后從long 轉到double |
| long |
char |
保留低位字節(jié) |
| long |
short |
保留低位字節(jié) |
| long |
unsigned char |
保留低位字節(jié) |
| long |
unsigned short |
保留低位字節(jié) |
| long |
unsigned long |
最高位失去符號位意義，變?yōu)閿?shù)據(jù)位 |
| long |
Float |
使用單精度浮點數(shù)表示?？赡軄G失精度。 |
| long |
double |
使用雙精度浮點數(shù)表示。可能丟失精度。 |
| long |
long double |
使用雙精度浮點數(shù)表示?？赡軄G失精度。 |
|
|
|
|
表2-5 |
| |
| 從 |
到 |
方法 |
| unsigned char |
char |
最高位作為符號位 |
| unsigned char |
short |
0擴展 |
| unsigned char |
long |
0擴展 |
| unsigned char |
unsigned short |
0擴展 |
| unsigned char |
unsigned long |
0擴展 |
| unsigned char |
float |
轉換到long; 再從 long 轉換到float |
| unsigned char |
double |
轉換到long; 再從 long 轉換到double |
| unsigned char |
long double |
轉換到long; 再從 long 轉換到double |
| unsigned short |
char |
保留低位字節(jié) |
| unsigned short |
short |
最高位作為符號位 |
| unsigned short |
long |
0擴展 |
| unsigned short |
unsigned char |
保留低位字節(jié) |
| unsigned short |
unsigned long |
0擴展 |
| unsigned short |
float |
轉換到long; 再從 long 轉換到float |
| unsigned short |
double |
轉換到long; 再從 long 轉換到double |
| unsigned short |
long double |
轉換到long; 再從 long 轉換到double |
| unsigned long |
char |
保留低位字節(jié) |
| unsigned long |
short |
保留低位字節(jié) |
| unsigned long |
long |
最高位作為符號位 |
| unsigned long |
unsigned char |
保留低位字節(jié) |
| unsigned long |
unsigned short |
保留低位字節(jié) |
| unsigned long |
float |
轉換到long; 再從 long 轉換到float |
| unsigned long |
double |
Convert directly to double |
| unsigned long |
long double |
轉換到long; 再從 long 轉換到double |
|
|
|
|
下面是一個使用變量的程序實例：
|
|
程序2-3： |
| |
#include <iostream.h>
int main (void)
{
1． int workDays = 5;
2． float workHours, payRate, weeklyPay;
3． workHours = 7.5; payRate = 38.55;
4． weeklyPay = workDays * workHours * payRate;
5． cout << "Weekly Pay = " << weeklyPay << '\n';
} |
|
第一行定義了一個整型變量workDays，并初始化為5，表示一周的工作天數(shù)。
第二行定義了三個實型變量，分別表示每天工作的小時數(shù)、每小時應支付的薪水及每周應支付的薪水。
第三行是兩個賦值語句。7.5 賦給變量workHours，38.55賦給變量payRate。
第四行是計算每周的工資，即三個變量workDays、workHours、payRate的積，*是乘運算符，結果保存在變量weeklyPay變量中。
第五行輸出字符串"Weekly Pay = "、變量weeklyPay 的值和換行符。
本程序的運行結果如下：
Weekly Pay = 1445.625
如果我們定義一個變量時，沒有給它賦初值，它的值是不定的。例如，在上面的第四行執(zhí)行前，weeklyPay的值是不定的。
變量第一次賦值稱之為初始化，變量在使用之前應當先初始化。
|
|
|
|
C++語言把字符型變量當作一個較小的整型量，可以象整型量一樣使用它。下面舉一個例子說明：
|
|
程序2-6 |
| |
#include <iostream.h>
void main()
{
char c1 = 'a';
char c2 = 'b';
char c3,c4;
c3 = c1 - ('a' - 'A');
c4 = c2 - ('a' - 'A');
cout<<c3<<c4<<endl;
}
運行結果為：
A B |
|
程序中的'a' - 'A'是大小寫字母之間的差值，其值為32。所以我們也可以把程序寫成：
c3 = c1 - 32;
c4 = c2 - 32;
如果我們想看一看c3、c4中到底存儲的值是多少，可以這樣：
cout<<(int)c3<<(int)c4<<endl;
其運行結果為：
65 66
注意：在內存中，字符數(shù)據(jù)以ASCII碼存儲，即以整數(shù)表示，'0'和0是不同的。
|
|
例2-1： |
| |
'\n' // 換行
'\r' // 回車
'\t' // 水平tab
'\v' // 垂直tab
'\b' // 退格
'\f' // 進紙
'\'' // 單引號 (')
'\"' // 雙引號 (")
'\\' // 反斜杠 (\) |
|
|
|
例2-2： |
| |
'\12' //換行(10進制編碼 = 10)
'\11' // 水平tab (10進制編碼= 9)
'\101' // 'A' (10進制編碼= 65)
'\0' // null (10進制編碼= 0) |
|
|
|
|
|
下面給出一個有常量定義的實例程序，這個程序是打印給定半徑的圓的面積和周長。
|
|
例2-6： |
| |
void main()
{
const double PI = 3.1415926535898; //定義圓周率常量PI
double radius; //定義圓半徑變量
double area; //定義圓面積變量
double circumference; //定義圓周長變量
cout << "Enter radius : ";
cin >> radius;
area = PI*radius*radius;
circumference = 2.0*PI*radius;
cout << "Area of circle of radius " << radius << " is "
<< area << " \n";
cout << "and its circumference is " << circumference
<< " \n";
}
運行該程序，并輸入半徑值10.0：
Enter radius : 10.0↙
則輸出結果為：
Area of circle of radius 10.0 is 314.159
and its circumference is 62.8319 |
|
常量就是在程序運行過程中其值不發(fā)生變化的量。常量可分為直接常量與符號常量。直接常量就是平常我們所說的常數(shù)，例如：
`r` // r為字符型直接常量
3.1415926 // 3.1415926為雙精度直接常量
符號常量就是用一個標識符代表某個常量。符號常量可用關鍵字const聲明，其格式如下：
const 數(shù)據(jù)類型 常量名＝常數(shù)值；
例如：
const int a= 1234; //定義a為整型常量其值為1234
const char b=`a` //定義b 為字符型常量其值為a
在程序設計中，盡量使用符號常量來代替常數(shù)，這是一種好的編程習慣，這樣可以增加程序的可讀性、可維護性。例如，在數(shù)值計算中，我們會經常遇到一些常量，比如圓周率。如果把它定義成符號常量，當需要更改常量值的時候，只需要更改符號常量的定義語句即可。
也可以使用預處理語句定義符號常量，例如我們用：
#define PI 3.14159
定義符號常量PI，然后在程序中使用PI，跟使用常數(shù)3.14159的效果是一樣的。編譯器在編譯時，把符號PI替換成3.14159，當需要修改PI的值時，只需要修改上面的語句即可。但是我們不推薦這樣做：因為預定義符號與符號常量不同，在編譯時使用常數(shù)替代了所有的預定義符號，這樣在代碼中相應位置實際都是常數(shù)。程序中過多的常數(shù)會導致程序代碼量變大，而且在多個源文件中定義了同樣的符號，會產生符號重定義的問題。使用常量優(yōu)于＃define宏，優(yōu)點在于可指定類型信息。
|
|
例2-7： |
| |
const double PI = 3.1415927; //圓周率π
const long number = 49L;
const char TAB = '\t';
const char QUERY = '?';
const double SOMENUM = 1.235E75;
|
|
|
2.7.1 標準輸出
輸出內置的數(shù)據(jù)類型到標準的輸出設備，用<<運算符和cout輸出流。例如：
cout << d; // 輸出d
cout << d << endl; // 輸出d并換行
cout << "This is the value of d : " << d << endl; // 輸出字符串、d并換行
一個語句中多次使用<<等價于<<單獨使用多次，即最后一個語句等價于：
cout << "This is the value of d : " ;
cout << d;
cout << endl;
符號endl的功能是換行，并清除輸出緩沖區(qū)。變量的值以缺省的格式打印，改變打印格式方法在后面介紹。
|
經驗：如何記<<和>>:cout是c出，出了就?。?lt;<）了； cin是c進，進則收入，就大(>>)
注意：cin流不使用指針引用變量，不應給cin傳遞一個指向變量的指針，如果這樣做cin將返回錯誤。例如，下面的程序cin_err.cpp ,當編譯它時將返回六個錯誤：
|
|
例2-8： |
| |
＃include <iostream.h>
void main(void)
{
int age;
float salary;
char name[128];
cout << "Enter your first name age salary: ";
cin >> &name >> &age >> &salary;
cout << name << " " << age << " " << salary;
} |
|
|
|
例2-9： |
| |
cout << " Enter the value of n : " << endl;
cin >> n;
而不要寫成：
cout << " Enter the value of n : ";
cin >> n; |
|
|
C++使用操縱符（在<iomanip.h>和<iostream.h>中定義），而C提供了一系列的說明符，參見表2-10。這些說明符用于輸出，也可用于輸入。
|
|
表2-10： |
| |
| 說明符 |
類型 |
| %wd |
int 或char |
|
w = 寬度 |
| %w.df |
double w = 總的寬度（包括小數(shù)點） d = 小數(shù)位數(shù) |
| %wc |
char 或int w = 寬度 |
| %ws |
char * (字符串) 格式 w = 寬度 |
| %wu |
unsigned int w = 寬度 |
| %wo |
八進制 |
| %wx |
十六進制 |
| %m.dddddde±xx %m.ddddddE±xx %m.ddddddg±xx %m.ddddddG±xx |
指數(shù)記數(shù)法 |
|
|
下面，我們給出一些格式實例，假定有下面的變量說明：
|
|
表2-11： |
| |
| 變量說明 |
int x = 98;
float y = 1.34567889;
char letter = 'A';
char word[] = "Hello"; |
|
|
下表給出了輸出這些變量的缺省的格式：
|
|
表2-12： |
| |
| 語句 |
printf("Default formats: %d %f %c %s\n", x,y,letter,word); |
| 結果 |
Default formats: 98 1.345679 A Hello |
|
|
我們也可以改變缺省的格式。需要注意的是：輸出結果是右對齊的，也就是說，當輸出結果的寬度小于指定的寬度時，空格填充到左邊：
|
|
表2-13： |
| |
| 格式說明 |
| 語句 |
printf("Width specified: %5d %10.4f %5c %10s\n", x,y,letter,word); |
| 結果 |
Width specified: 98 1.3457 A Hello |
|
|
我們也可以打印變量的內存地址信息，但要使用unsigned格式說明符：
|
|
表2-14： |
| |
| 打印內存地址 |
| 語句 |
printf("Address of x: %u Address of y: %u\n", &x, &y); |
| 結果 |
Address of x: 4026528400 Address of y: 4026528396 |
|
|
|
|
|
|
|
|
|
|
|
