當前位置: 首頁>>技術教程>>正文


C++:了解指針

作者:魯伯斯·倫德克

日期:2009年9月10日

更新:2010年4月3日-創建了第7.2節,以闡明C++中的指針與數組之間的關係

介紹

本文麵向所有希望了解C++語言指針的所有級別的編程愛好者。這裏提供的所有代碼都不是特定於編譯器的,並且所有示例都將以普通ANSI C++編寫。關於指針的爭論可能綿延數英裏,您需要走很長一段路才能掌握所有知識。如果您真的想跑那麽遠,本文將使您對指針的基本概念有一個清晰的了解,並為您的旅程做準備。但是,對於C++編程不熟悉的人請確保您能夠編寫和運行自己的C++ “hello world”程序,並且建議您對C++函數和類有基本的了解。如果您需要刷新有關如何編譯和運行C++程序,使用函數和類的知識,請閱讀附錄在繼續閱讀本文之前,請先閱讀本文末尾的內容。

什麽是指針?

指針是存儲內存地址的變量。 OK,那很簡單!但是,什麽是內存地址?每個變量都位於計算機內存中的唯一位置下,並且該唯一位置具有其自己的唯一地址,即內存地址。通常,變量保存諸如5或“hello”之類的值,並且這些值存儲在計算機內存中的特定位置下。但是,指針是另一種野獸,因為它持有內存地址作為其值,並能夠通過使用其關聯的內存地址來“point”(因此是指針)指向內存中的某個值。




檢索變量的內存地址

好,足夠多的交談,讓我們開始討論指針業務。要檢索變量的內存地址,我們需要使用address-of運算符&。

#include <iostream>
int main()
{
using namespace std;
// Declare an integer variable and initialize it with 99
unsigned short int myInt = 99;
// Print out value of myInt
cout << myInt << endl;
// Use address-of operator & to print out
// a memory address of myInt

cout << &myInt << endl;

return 0;
}

OUTPUT:

99
0xbff26312

輸出的第一行包含一個整數值99,第二行包含一個打印出的myInt內存地址。請注意,您的輸出將有所不同。

將變量的內存地址分配給指針

在為指針分配內存地址之前,我們需要聲明一個地址。在C++中聲明指針就像聲明任何其他具有一個區別的變量一樣簡單。需要添加Asterix符號“ *”,並將其放置在變量類型之後和變量名稱之前。將內存地址分配給指針時,必須遵循一個規則:指針類型必須與其將指向的變量類型匹配。一個例外是指向void的指針,該指針可以處理它將指向的不同類型的變量。為了聲明類型為unsigned short int的指針pMark,將使用以下語法:

#include <iostream>

int main()
{
using namespace std;

// Declare and initialize a pointer.
unsigned short int * pPointer = 0;
// Declare an integer variable and initialize it with 35698
unsigned short int twoInt = 35698;
// Declare an integer variable and initialize it with 77
unsigned short int oneInt = 77;
// Use address-of operator & to assign a memory address of twoInt to a pointer
pPointer = &twoInt;
// Pointer pPointer now holds a memory address of twoInt

// Print out associated memory addresses and its values
cout << "pPointer's memory address:\t\t" << &pPointer << endl;
cout << "Integer's oneInt memory address:\t" << &oneInt << "\tInteger value:\t" << oneInt << endl;
cout << "Integer's twoInt memory address:\t" << &twoInt << "\tInteger value:\t" << twoInt << endl;
cout << "pPointer is pointing to memory address:\t" << pPointer << "\tInteger value:\t" << *pPointer << endl;

return 0;
}

OUTPUT:

pPointer's memory address:              0xbff43314
Integer's oneInt memory address: 0xbff43318 Integer value: 77
Integer's twoInt memory address: 0xbff4331a Integer value: 35698
pPointer is pointing to memory address: 0xbff4331a Integer value: 35698

C++ pointer example diagram



上圖是對如何在計算機內存中存儲變量的高級可視化抽象。指針pPointer從內存地址0xbff43314開始,占用4個字節。指針pPointer將short int twoInt(2個字節)的內存地址作為值保存,該地址為0xbff4331a。該地址作為二進製數據存儲在指針的內存空間分配中。因此,取消引用具有內存地址0xbff4331a的指針將間接訪問值twoInt,在這種情況下,其值為正整數36698。

訪問指針持有的內存地址中的值

正如您在前麵的示例中看到的那樣,指針pMark真正擁有一個oneInt的值存儲地址。通過指針訪問變量值的過程稱為間接訪問,因為變量的值是間接訪問的。現在可以使用pPointer指針間接訪問oneInt的值。為此,我們需要使用取消引用運算符“ *”來取消對指針的引用,該運算符必須放置在指針變量名稱之前:

#include <iostream>

int main()

{
using namespace std;
// Declare an integer variable and initialize it with 99
unsigned short int myInt = 99;
// Declare and initialize a pointer
unsigned short int * pMark = 0;
// Print out a value of myInt
cout << myInt << endl;
// Use address-of operator & to assign a memory address of myInt to a pointer
pMark = &myInt;
// Dereference a pMark pointer with dereference operator * to access a value of myInt
cout << *pMark << endl;

return 0;
}

OUTPUT:

99
99

用指針處理數據

與通過間接訪問指針所保存的內存地址處的值相同,也可以使用間接來操作變量的值。將值分配給取消引用的指針將間接更改指針指向的變量的值。以下示例說明了使用指針對數據進行的簡單操作:

#include <iostream>

int main()

{
using namespace std;
// Declare an integer variable and initialize it with 99
unsigned short int myInt = 99;
// Declare and initialize a pointer
unsigned short int * pMark = 0;
// Print out a value of myInt
cout << myInt << endl;
// Use address-of operator & to assign memory address of myInt to a pointer
pMark = &myInt;
// Dereference a pMark pointer with dereference operator * and set new value
*pMark = 11;
// show indirectly a value of pMark and directly the value of myInt
cout << "*pMark:\t" << *pMark << "\nmyInt:\t" << myInt << endl;

return 0;
}

OUTPUT:

99
*pMark: 11
myInt: 11

取消引用pMark指針並將新值分配為11會將myInt的值也間接更改為11。再次提醒您,指針僅保留變量的內存地址而不是變量的值很重要。要訪問指針所指向的變量的值,必須由取消引用運算符“ *”取消引用。注意“ *”不是乘法,通過C++代碼的上下文,如果您打算使用乘法或解引用運算符,則編譯器將進行區分。



C++語言中的指針和數組

在C++中,數組名稱是指向其第一個元素的常量指針。 c ++指針與數組之間的關係密切相關,其用法幾乎可以互換。考慮以下示例:

#include <iostream>

int main()
{
using namespace std;
// Declare an array with 10 elements
int Marks [10]= {1,2,3,4,5,6,7,8,9,0};
// Print out the memory address of an array name
cout << Marks << endl;
// Print out the memory address of a first element of an array
cout << &Marks[0] << endl;
// Print out value of the first element by dereferencing a array name
cout << *Marks << endl;
return 0;
}

OUTPUT:

0xbf83d3fc
0xbf83d3fc
1

如您所見,數組名稱確實是指向其第一個元素的指針,因此通過const指針訪問數組元素是完全合法的。因此,取消引用數組名稱將訪問給定數組的第一個元素的值。下一個示例將演示如何通過conts指針訪問數組的其他元素。

#include <iostream>

int main()
{
using namespace std;

// Declare an array with 10 elements
int Marks [10]= {1,2,3,4,5,6,7,8,9,0};
// Create a constant pointer to Marks array
const int *pMarks = Marks;
// Access a 6th element of an array by pMarks pointer
cout << *(pMarks + 5) << endl;
// Access a 6th element by dereferencing array name
cout << *(Marks + 5) << endl;
// Access a 6th element of an array
cout << Marks[5] << endl;

return 0;
}

OUTPUT:

6
6
6

數組的第6個元素可以用指針表達式*(Marks + 5)引用。另外,可以聲明另一個常量指針,並為其分配數組第一個元素的內存地址的值。然後,該指針的行為與最初聲明的Marks數組相同。 “ +”符號告訴編譯器從數組的開頭移動5個整數對象。如果對象是整數(如本例所示)(整數通常為4個字節),這將導致指針指向第一個數組元素保留的地址後20個字節的內存地址,從而指向第6個。下麵的示例詳細說明了此想法:

#include <iostream>
int main()
{
using namespace std;
// Declare an array with 10 elements
int Marks [10]= {1,2,3,4,5,6,7,8,9,0};
// Create a constant pointer to Marks array
const int *pMarks = Marks;

for (int i=0, bytes=0; i < 10; ++i, bytes+=4)
{
cout << "Element " << i << ": " << pMarks << " + ";
cout << bytes << " bytes" << " = " << (pMarks + i) << endl;
}
return 0;
}

OUTPUT:

Element 0: 0xbfa5ce0c + 0 bytes = 0xbfa5ce0c
Element 1: 0xbfa5ce0c + 4 bytes = 0xbfa5ce10
Element 2: 0xbfa5ce0c + 8 bytes = 0xbfa5ce14
Element 3: 0xbfa5ce0c + 12 bytes = 0xbfa5ce18
Element 4: 0xbfa5ce0c + 16 bytes = 0xbfa5ce1c
Element 5: 0xbfa5ce0c + 20 bytes = 0xbfa5ce20
Element 6: 0xbfa5ce0c + 24 bytes = 0xbfa5ce24
Element 7: 0xbfa5ce0c + 28 bytes = 0xbfa5ce28
Element 8: 0xbfa5ce0c + 32 bytes = 0xbfa5ce2c
Element 9: 0xbfa5ce0c + 36 bytes = 0xbfa5ce30

考慮以下指針算術運算:
由於我們知道這個特定的數組包含整數,並且整數的長度為4個字節,因此為整個數組保留的內存為40個字節。內存地址0xbfa5ce0c是數組的第一個元素所在的位置。向第一個元素的地址添加20個字節(0x16)將返回第6個元素的地址:0xbfa5ce0c + 0x16(20個字節)= 0xbfa5ce20




指針數組

在C++中,也可以聲明一個指針數組。這樣的數據結構可用於創建字符串數組(string array)。在C++中,字符串實際上是指向其第一個字符的指針,因此,字符串數組本質上將是指向每個數組元素中字符串的第一個字符的指針的數組。

#include <iostream>
int main()
{
using namespace std;

const char *linuxDistro[6] =
{ "Debian", "Ubuntu", "OpenSuse", "Fedora", "Linux Mint", "Mandriva"};

for ( int i=0; i < 6; i++)
cout << linuxDistro[i] << endl;

return 0;
}

OUTPUT:

Debian
Ubuntu
OpenSuse
Fedora
Linux Mint
Mandriva

指針與數組

添加本節的目的是闡明C++中的指針與數組之間的關係,普通讀者可能會跳過它。當努力解釋C++中的指針和數組實際上是如何工作時,先前的指針和數組非常相似並且幾乎可以互換的說法是一個很好的定義。結果,對這些相似性的理解擴大了程序員對C++的了解。

關於C++中的指針和數組如何以及在何種程度上相關的討論很多。為了回答這個問題,我們需要詢問C++語言的創建者Bjarne Stroustrup。比尼亞·斯特魯斯特魯普(Bjarne Stroustrup)在他的書中寫道C++編程語言-第三版
在C++中,指針和數組密切相關。數組的名稱可用作指向其初始元素的指針。確保將指針指向數組末尾之外的元素可以正常工作。這對於許多算法而言都很重要。但是,由於這樣的指針實際上並不指向數組的元素,因此它可能無法用於讀取和寫入。在初始元素之前獲取元素地址的結果是不確定的,應該避免。在某些機器體係結構上,數組通常分配在機器尋址邊界上,因此“在初始元素之前一個”根本沒有意義。



為什麽我們需要指針?

到目前為止,您已經了解了C++指針背後的一些理論和語法。您學習了如何將變量的內存地址分配給指針。為指針分配地址有助於解釋指針的工作方式。但是,在現實生活中,您絕不會這樣做。此時正確的問題是:如果僅使用變量的聲明名稱就可以訪問和操縱變量,為什麽我們需要C++語言的指針? C++通過指針直接訪問內存的能力使C++語言優於某些其他語言,例如Visual Basic,C#或Java。直接通過指針而不是通過它們的內存位置訪問變量可以提高編寫代碼的效率和靈活性。但是,可以預見的是,提高效率需要付出成本,因為使用任何low-level工具(例如指針)都意味著實施難度加大。指針最常見的用途包括:

  • 免費商店中的數據管理
  • 訪問類成員數據和函數
  • 通過引用傳遞變量

我們在哪裏使用指針?

在本節中,我們將探討在C++語言中使用指針的幾種不同方式。

從”Free Store”分配內存

一旦將返回值傳遞回調用語句,就將銷毀在函數定義內本地聲明和使用的變量。這種將值傳遞給函數的方法的優點是,程序員不必釋放由函數的局部變量分配的內存,並且傳遞給函數的變量不能更改。當功能範圍內的聲明變量需要由其他功能使用而又不產生通過功能返回值複製這些變量的開銷時,就會出現不利之處。

解決此問題的一種方法是創建全局變量。但是,這總是導致代碼的可讀性,效率和錯誤降低,因此,應盡可能避免聲明全局變量。全局名稱空間中已聲明的全局變量在整個程序運行時中都持有分配的內存,並且通常隻需要很短的時間。

想象一下,程序員將能夠在程序運行時動態分配內存。此內存分配也可以在代碼中的任何位置使用,並且不再需要在任何時間釋放。這就是所謂的“Free Store”出現的地方。空閑存儲是供程序員在程序執行期間動態分配的內存和de-allocated。

用以下方式分配內存操作者

需要在免費存儲區中分配內存時,將使用new運算符。新操作符的返回值是一個指針。因此,應僅將其分配給指針。這是一個例子:

#include <iostream>
int main()
{
using namespace std;
// Delcare a pointer
unsigned short * pPointer;
// allocate a memory with a new operator on the free store
// and assign a memory address to a pointer named pPointer
pPointer = new unsigned short;
// assign an integer value to a pointer
*pPointer = 31;
// Print out the value of pPointer
cout << *pPointer << endl;

return 0;
}

OUTPUT:

31

僅在實際程序結束時才釋放在程序運行時分配的空閑存儲內存。對於這個簡短的程序,沒關係,但是de-allocating並不是免費的內存,這不是一個好的編程習慣,更重要的是,您的代碼通常包含11行以上。

De-allocating具有的內存刪除操作者

要將分配的內存返回給免費存儲,將使用刪除操作符:

#include <iostream>
int main()
{
using namespace std;
// Delcare a pointer
unsigned short * pPointer;
// allocate a memory with a new operator on the free store
// and assign a memory address to a pointer named pPointer
pPointer = new unsigned short;
// assign an integer value to a pointer
*pPointer = 31;
// de-allocating memory back to the free store
delete pPointer;
// Print out a value of pPointer
cout << *pPointer << endl;

return 0;
}

OUTPUT:

0

delete運算符釋放由新運算符分配的內存,並將其返回到空閑存儲。指針的聲明仍然有效,因此可以重新分配pPointer。刪除運算符隻是使用指針刪除了關聯的內存地址。

注意:重要的是要提到,即使在刪除操作符之後,指針也應始終初始化。不這樣做可以創建所謂的流浪指針可能會導致不可預測的結果,因為流浪指針可能仍指向內存中的舊位置,並且編譯器可以使用該內存地址來存儲其他數據。程序可以正常運行。但是,已設置了使程序崩潰的定時炸彈,並且該計時器正在運行。




數據類型類指針

聲明類型類數據指針與聲明任何其他數據類型的指針沒有什麽不同。考慮以下示例,在該示例中將構建簡單的Heater類來演示此概念。

#include <iostream>

using namespace std;
class Heater
{
// Declare public functions for class heater
public:
// constrator to initialise temperature
Heater( int itsTemperature);
// destructor, takes no action
~Heater();
// accessor function to retrieve temperature
int getTemperature() const;
// declare private data members
private:
int temperature;
};
// definition of constractor
Heater::Heater(int itsTemperature)
{
temperature = itsTemperature;
}
// definition of destructor
Heater::~Heater()
{
// no action taken here
}
// Definition of an accesor function which returns a value of a private Heater class member temperature
int Heater::getTemperature() const
{
return temperature;
}

int main()
{
// define a Heater class pointer object and initialize temperature to 8 by use of constructor
Heater * modelXYZ = new Heater(8);
// Access an accessor function getTemperature() to retrieve temperature via an object modelXVZ
cout << "Temperature of heater modelXYZ is :" << modelXYZ->getTemperature() << endl;
// Free an allocated memory back to a free store
delete modelXYZ;

return 0;
}

OUTPUT:

Temperature of heater modelXYZ is :8

上麵代碼的最大一部分專用於類定義。從指針的角度來看,對我們來說有趣的部分是主要功能。空閑存儲中的內存分配給Heater類的新指針對象modelXYZ。在此代碼的下一行,通過使用箭頭運算符引用指針對象來調用訪問器函數 getTemperature()。最後,釋放除了免費存儲區之外的內存。重要的是要提到,當一個對象被聲明為指針時,不能使用通常用於訪問類成員函數的(。)運算符,當一個類對象被聲明為指針時,必須使用箭頭(->)運算符代替。

使用指針通過引用傳遞給函數

除了按值和引用傳遞外,還可以使用指針將參數傳遞給函數。考慮以下示例:

#include <iostream>

using namespace std;

// FUNCTION PROTOTYPE
// passing to a function by reference using pointers
void addone( int * a, int * b);

int main()
{
// define integers a and b
int a = 1;
int b = 4;

cout << "a = " << a << "\tb = " << b << endl;
// addone() function call
cout << "addone() function call\n";
addone(&a,&b);
// after addone() function call value a=2 and b=5
cout << "a = " << a << "\tb = " << b << endl;

return 0;
}

// addone() fuction header
void addone( int * a, int * b)
{
// addone() function definition
// this function adds 1 to each value
++*a;
++*b;
}

OUTPUT:

a = 1   b = 4
addone() function call
a = 2 b = 5

addone函數的函數原型包含作為可接受的變量類型的指針. addone()函數將1從主函數添加到每個在函數調用期間已傳遞內存地址的變量。必須知道,使用指向指針的引用作為傳遞參數,還可以在 addone()函數範圍之外更改所涉及的值。這與程序員按值傳遞給函數的情況完全相反。請參閱附錄在本文末尾,列出了有關如何通過值和引用傳遞給函數的示例。



與指針相關的內存泄漏

正如上麵已經提到的,使用指針和新運算符賦予了程序員巨大的力量。強大的力量往往伴隨著巨大的責任。釋放存儲空間的錯誤操作可能導致內存泄漏。接下來,我們將說明一些與C++指針相關的內存泄漏的實例。

重新分配指針導致內存泄漏

當不再需要從免費存儲區分配的內存並且刪除操作員不釋放它時,就會發生內存泄漏。發生這種情況的一種方法是,在刪除運算符有機會執行其工作之前重新分配一個指針:

#include <iostream>
int main()
{
using namespace std;
// Delcare a pointer
unsigned short * pPointer;
// allocate a memory with a new operator on the free store
// and assign a memory address to a pointer named pPointer
pPointer = new unsigned short;
// assign an integer value to a pointer
*pPointer = 31;
// print out the value of pPointer and its associated memory address
cout << "*pPointer Value: " << *pPointer << "\tMemory Address: " << pPointer << endl;
// reassign a pointer to a new memory address from a free store
pPointer = new unsigned short;
// assign an integer value to a pointer
*pPointer = 15;
// print out a value of pPointer and its corresponding memory address
cout << "*pPointer Value: " << *pPointer << "\tMemory Address: " << pPointer << endl;
// de-allocating memory back to the free store
delete pPointer;

return 0;
}

OUTPUT:

*pPointer Value: 31     Memory Address: 0x90e9008
*pPointer Value: 15 Memory Address: 0x90e9018

分析內存泄漏示例的輸出:

  1. pPointer擁有一個內存地址(0x90e9008),它指向整數值15。
  2. 通過從空閑存儲區分配新的內存,為pPointer重新分配了新的內存地址。
  3. 指向值31的原始內存地址丟失,因此無法釋放。
  4. 現在,pPointer擁有一個內存地址(0x90e9018),該地址指向值15的整數。
  5. 地址為0x90e9018的已分配內存為de-allocated。
  6. 由於程序終止,釋放了地址為0x90e9008的已分配內存。

濫用局部變量導致內存泄漏

當函數返回值或執行其最後一條語句時,在函數定義內聲明的所有變量都將被銷毀,並且不再可以從堆棧段中訪問。這可能會導致問題:將空閑存儲區中的哪些內存分配給在函數定義中本地聲明的指針,並且在超出範圍之前不會使用delete運算符釋放該內存。下一個示例將概述它的發生方式:

#include <iostream>
// function prototype
void localPointer();

int main()
{
// function call from the main function

localPointer();

return
0;
}

// function header

void localPointer()
{
// function definition
// variable declaration pPointer of type pointer
unsigned short int * pPointer;
// allocate a new memory from the free store and assign its memory address to a pointer pPointer
pPointer = new unsigned short int;
// initialise pPointer
*pPointer = 38;
// print out a value to which pPointer is pointing to
std::cout << "Value of *pPointer : " << *pPointer << std::endl;
// de-allocation statement "delete pPointer;" is missing here

// function end
}

OUTPUT:

Value of *pPointer : 38

當function localPointer()退出時,將刪除存在於函數範圍內的所有變量。 pPointer還是在本地聲明的變量,因此,與免費存儲中分配的內存關聯的內存地址將丟失,因此不可能de-allocate。該程序將在此簡單示例中正常運行。但是,每次調用函數 localPointer()時,都會留出一個新內存而不釋放它,這將降低程序的效率並導致程序崩潰。有關內存泄漏的更多示例,請參見



結論

正如前麵已經提到的,指針為掌握它們的任何軟件工程師賦予了強大的力量。本文嘗試通過使用示例以簡單的方式介紹指針,以便讀者可以很好地實現該目標。通過指針直接訪問內存是C++語言的最佳功能之一,因此,對於嵌入式設備編程而言,這也是首選的語言。使用指針時,必須格外小心,因為強大的功能可能會迅速變成災難。

有用的鏈接:

這裏有一些很棒的鏈接,可以增進對C++指針的理解。

附錄

編寫,編譯和執行C++ “hello world”

#include <iostream>

int main()
{
using namespace std;
cout << "Hello world\n";

return 0;
}

編譯:

g++ hello-world.cc -o hello-world

執行:

./hello-world

OUTPUT:

Hello World


C++函數基礎

請注意,以下程序僅用於修訂目的。它不應作為C++函數的完整指南。請訪問以下鏈接,以更好地了解如何使用C++函數:

#include <iostream>

using namespace std;

// FUNCTION PROTOTYPES

// passing to a function by value
int add( int a, int b);
// passing to a function by reference using pointers
void addone( int * a, int * b);
// passing to a function by reference using reference
void swap( int &a, int &b);

int main()

{
// define integers a and b
int a = 1;
int b = 4;

// add() function call return value will be printed out
cout << "add() function\n";
cout << add(a,b) << endl;
cout << "a = " << a << "\tb = " << b << endl;
// addone() function call
cout << "addone() function\n";
addone(&a,&b);
// after addone() function call value a=2 and b=5
cout << "a = " << a << "\tb = " << b << endl;
// swap() function call
cout << "swap() function\n";
swap(a,b);
// after swap() function call value a=5 and b=2
cout << "a = " << a << "\tb = " << b << endl;

return 0;
}
// add() fuction header
int add( int a, int b)
{
// add() function definition
// this function returns sum of two integers
return a + b;
}

// addone() fuction header
void addone( int * a, int * b)
{
// addone() function definition
// this function adds 1 to each value
++*a;
++*b;
}

// swap() function header
void swap( int &a, int &b)
{
// swap() function definition
// this function swaps values
int tmp;

tmp = a;
a = b;
b = tmp;
}

OUTPUT:

add() function
5
a = 1 b = 4
addone() function
a = 2 b = 5
swap() function
a = 5 b = 2


C++類基礎知識

請注意,以下程序僅用於修訂目的。它不應作為C++類的完整指南。請訪問以下鏈接,以更好地了解如何使用C++類:

#include <iostream>

using namespace std;
class Heater
{
// declare public functions for class heater
public:
// constrator to initialize a private data member temperature
Heater( int itsTemperature);
// destructor, takes no action
~Heater();
// accessor function to retrieve a private date member temperature
int getTemperature() const;
// declare private data members
private:
int temperature;
};
// definition of constractor
Heater::Heater(int itsTemperature)
{
temperature = itsTemperature;
}
// definition of destructor
Heater::~Heater()
{
// no action taken
}
// definition of accesor function which returns value of a private Heater class member temperature
int Heater::getTemperature() const
{
return temperature;
}

int main()
{
// define a Heater class object and initialise temperature to 8 by calling a constructor
Heater modelXYZ(8);
// access accessor function getTemperature() to retrieve temperature via object modelXVZ
cout << "Temperature of heater modelXYZ is :" << modelXYZ.getTemperature() << endl;
return 0;

}

OUTPUT:

Temperature of heater modelXYZ is :8

參考資料

本文由Ubuntu問答整理, 博文地址: https://ubuntuqa.com/zh-tw/article/7398.html,未經允許,請勿轉載。