VB2008从入门到精通(PDF格式英文版)-第24部分

快捷操作: 按键盘上方向键 ← 或 → 可快速上下翻页 按键盘上的 Enter 键可回到本书目录页 按键盘上方向键 ↑ 可回到本页顶部! 如果本书没有阅读完，想下次继续接着阅读，可使用上方 "收藏到我的浏览器" 功能 和 "加入书签" 功能！


　　　　　　　　　　　　would　be　exposed　like　a　wallet　that　is　allowed　to　be　peeked　into　by　the　general　public。　This　means　　

　　　　　　　　　　　　the　types　can　be　used　by　other　code。　In　the　case　of　the　wallet；　it’s　a　bad　idea　to　have　unfettered　　

　　　　　　　　　　　　public　scope；　but　sometimes　public　scope　is　desirable　when　you　are　able　to　control　its　access。　　

　　　　　　　　　　　And　you　do　this　every　time　you　pay　for　something　by　handing　a　credit　card　to　the　cashier。　In　　

　　　　　　　　　　　　that　case；　you　are　publicly　exposing　parts　of　your　wallet　under　your　supervision。　In　code　terms；　　

　　　　　　　　　　　　this　means　making　your　types　public；　but　not　necessarily　making　the　data　members　public。　

　　　　　　　　　　　　　　　　　Next；　consider　the　code　in　Figure　4…5。　It　instantiates　MyValueType　and　assigns　it　to　another　　

　　　　　　　　　　　　variable　of　the　same　type。　

　　　　　　　　　　　　　　　　　The　example　in　Figure　4…5　illustrates　what　happens　to　two　variables　when　one　is　instanti

　　　　　　　　　　　　ated　and　assigned　to　the　other；　and　then　the　other　is　modified。　You　want　to　understand　how　　

　　　　　　　　　　　　each　data　type　is　modified　when　an　interaction　with　another　type　occurs。　　


…………………………………………………………Page　105……………………………………………………………

　　　　　　　　　　　　　　　　　　　　　　　　　CH　AP　T　E　R　　　4　　　■　　　　L　E　A　R　N　I　N　G　　　A　B　OU　T　　　D　AT　A　　S　TR　U　CT　U　R　E　S；　　　DE　CI　SI　ON　S；　　　A　N　D　　　L　O　OP　S　83　



　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　To　create　a　valid　instance　

　　　　Variable　var　is　declared；　　　　　　　　　　　associated　with　the　

　　　but　a　declaration　does　not　　　　　　　　　variable　var；　you　need　to　

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　Another　way　to　associate　a　

　　　　　　imply　a　valid　instance　　　　　　　　　　allocate　the　object　using　　　　　　　valid　instance　with　a　variable　is　

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　the　New　keyword　

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　to　assign　the　variable　

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　（e。g。；　copiedVar）　from　another　

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　variable　that　contains　a　valid　

　Dim　var　As　MyValueType　=　New　MyValueType（）　

　Dim　copiedVar　As　MyValueType　=　var　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　instance　（e。g。；　var）　



　Console。WriteLine（〃var　value=〃　&　var。value　&　_　

　　　　　〃　copiedVar　value=〃　&　copiedVar。value）　　　　　　　　　　　　　　　　　　　　　　　　When　an　instance　is　allocated；　the　data　

　var。value　=　10　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　members　are　assigned　their　appropriate　

　Console。WriteLine（〃var　value=〃　&　var。value　&　_　　　　　　　　　　　　　　　　default　value；　which　is　0　for　Integer　and　most　

　　　　　〃　copiedVar　value=〃　&　copiedVar。value）　

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　numbers。　For　strings；　it　is　an　empty　buffer。　

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　These　lines　display　the　empty　values。　



　　　　　The　value　of　var。value　is　

　　　　　　　modified　from　0　to　10　　　　　　　　　　　　　　　The　contents　of　var　and　copiedVar　

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　are　displayed　again　to　show　

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　which　variable　has　been　modified　



Figure　4…5。　　Using　a　custom　value　type　　



　　　　　　As　a　parison；　the　same　operations　can　be　carried　out　using　a　reference　type；　where　the　　

reference　code　is　as　follows：　



Dim　val　As　MyReferenceType　=　New　MyReferenceType（）　

Dim　copiedVal　As　MyReferenceType　=　val　



Console。WriteLine（〃val　value=〃　&　val。value　&　_　

　　　　〃　copiedVal　value=〃　&　copiedVal。value）　

val。value　=　10　

Console。WriteLine（〃val　value=〃　&　val。value　&　_　

　　　　〃　copiedVal　value=〃　&　copiedVal。value）　



　　　　　　So；　if　two　code　pieces　are　functionally　identical；　with　the　single　difference　being　their　type　　

（value　type　versus　reference　type）；　will　they　generate　the　same　results？　

　　　　　　Running　both　code　pieces　results　in　the　following　output：　



var　value=0　copiedVar　value=0　

var　value=10　copiedVar　value=0　

val　value=0　copiedVal　value=0　

val　value=10　copiedVal　value=10　



　　　　　　Looking　closely　at　the　results；　you　see　that　two　functionally　identical　code　pieces　that　differ　　

only　in　the　variable　type　they　use　generate　pletely　different　results：　　


…………………………………………………………Page　106……………………………………………………………

84　　　　　　　　CH　AP　T　E　R　　　4　　　■　　　　L　E　A　R　N　IN　G　　　AB　OU　T　　　D　AT　A　　S　TR　U　CT　U　R　E　S；　　　DE　CI　SI　ON　S；　　　A　N　D　　　L　O　OP　S　



　　　　　　　　　　　　　　　o　　When　you　assign　and　modify　a　value　type；　only　the　contents　of　the　modified　variable　　

　　　　　　　　　　　　　　　　　　change。　



　　　　　　　　　　　　　　　o　　When　you　assign　and　modify　a　reference　type；　the　original　object　changes；　so　the　original　　

　　　　　　　　　　　　　　　　　　variable　and　assigned　variable　change　because　they　both　point　to　the　same　original　object。　



　　　　　　　　　　　　　　　　This　example　demonstrates　that　when　defining　user…defined　types；　you　need　to　be　careful　　

　　　　　　　　　　how　you　treat　value　and　reference　types。　

　　　　　　　　　　　　　　　　As　you　learned　in　Chapter　2；　a　value　type　is　stored　on　the　stack。　Thus；　declaring　a　user

　　　　　　　　　　　defined　value　type　means　the　full　contents　of　the　user…defined　type　are　stored　on　the　stack；　and　　

　　　　　　　　　　when　you　assign　one　value　type　variable　to　another　value　type　variable；　you　are　copying　the　　

　　　　　　　　　　　plete　contents　of　the　value　type。　This　copying　was　obvious　in　our　example　when　we　used　　

　　　　　　　　　　　simple　numeric　number　types　（such　as　Double）；　but　when　you　copy　plete　structures　with　　

　　　　　　　　　　　contents；　the　side　effects　might　not　be　what　you　expect。　



　　　　　　　　　　Value　Types　That　Contain　Reference　Types　



　　　　　　　　　　Value　types　copy　the　contents　when　you　assign　variables；　but　there　is　caveat　in　that　this　rule　　

　　　　　　　　　　　does　not　apply　if　the　value　type　contains　a　reference　type。　Consider　the　following　declaration。　



　　　　　　　　　　　Structure　MyValueTypeWithReferenceType　　

　　　　　　　　　　　　　　Public　value　As　Integer　

　　　　　　　　　　　　　　Public　reference　As　MyReferenceType　

　　　　　　　　　　　End　Structure　



　　　　　　　　　　　　　　　　The　first　line　in　the　value　type　declaration　contains　a　single　value　type　（Integer）。　The　second　　

　　　　　　　　　　line　is　the　data　member　declaration　that　is　a　reference　type。　The　declaration　implies　that　the　　

　　　　　　　　　　value　type　is　stored　on　the　stack；　but　the　reference　type　is　on　the　heap。　

　　　　　　　　　　　　　　　　The　value　type　that　contains　a　reference　type　is　manipulated　using　the　following　test　code。　



　　　　　　　　　　　Dim　var　As　MyValueTypeWithReferenceType　=　New　MyValueTypeWithReferenceType（）　

　　　　　　　　　　　var。reference　=　New　MyReferenceType（）　

　　　　　　　　　　　Dim　copiedVar　As　MyValueTypeWithReferenceType　=　var　



　　　　　　　　　　　Console。WriteLine（〃var　value=〃　&　var。reference。value　&　_　

　　　　　　　　　　　　　　〃　copiedVar　value=〃　&　copiedVar。reference。value）　

　　　　　　　　　　　var。reference。value　=　10　

　　　　　　　　　　　Console。WriteLine（〃var　value=〃　&　var。reference。value　&　_　

　　　　　　　　　　　　　　〃　copiedVar　value=〃　&　copiedVar。reference。value）　



　　　　　　　　　　　　　　　　It　is　important　to　realize　that　allocating　MyValueTypeWithReferenceType　does　not　imply　　

　　　　　　　　　　　an　allocation　of　the　embedded　custom　type。　In　the　test　code；　the　allocation　of　the　　

　　　　　　　　　　MyValueTypeWithReferenceType　is　the　same　as　the　previous　code　examples；　but　a　second　allocation　　

　　　　　　　　　　　of　MyReferenceType　is　required　because　MyReferenceType　is　a　reference　type。　Had　MyReferenceType　　

　　　　　　　　　　been　a　value　type；　the　allocation　would　not　have　been　necessary。　But　if　you　allocate　a　value　　

　　　　　　　　　　　type　like　a　reference　type；　the　piler　will　ignore　the　directive。　


…………………………………………………………Page　107……………………………………………………………

　　　　　　　　　　　　　　　　　　　　　　　CH　AP　T　E　R　　　4　　　■　　　　L　E　A　R　N　I　N　G　　　A　B　OU　T　　　D　AT　A　　S　TR　U　CT　U　R　E　S；　　　DE　CI　SI　ON　S；　　　A　N　D　　　L　O　OP　S　85　



　　　　　Running　the　test　code　results　in　the　following：　



var　value=0　copiedVar　value=0　

var　value=10　copiedVar　value=10　



　　　　　When　you　assign　and　modify　an　embedded　reference　type；　the　reference　type　instance　is　　

modified　for　both　variables。　In　this　case；　when　we　assigned　the　value　type；　the　contents　were　　

copied；　including　the　pointer　to　the　reference　type。　

　　　　　Table　4…1　summarizes　the　behavior　of　types　when　the　allocated　variable　is　assigned　to　　

another　variable　and　the　data　member　from　the　original　is　modified。　For　example；　if　the　code　　

is　custom2　=　custom1　custom1。member　=　＇new　value＇；　what’s　the　value　of　custom2。member？　　



Table　4…1。　Behavior　When　the　Allocated　Variable　Is　Assigned　to　Another　Variable　and　the　Data　　

Member　from　the　Original　Is　Modified　



Type　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　Behavior　



Value　type　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　Assigned　data　member　is　not　modified　



Reference　type　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　Assigned　data　member　is　modified　



Value　type　embedding　value　type　　　　　　　　　　　　　　　　　　　Assigned　embedded　data　member　is　not　modified　



Value　type　embedding　reference　type　　　　　　　　　　　　　　　Assigned　embedded　data　member　is　modified　



Reference　type　embedding　value　type　　　　　　　　　　　　　　　Assigned　embedded　data　member　is　modified　



Reference　type　embedding　　　　　　　　　　　　　　　　　　　　　　　　　　Assigned　embedded　data　member　is　modified　

reference　type　



Value　Types　and　Parameters　



Another　value　type　constraint　relates　to　how　variables　are　stored　and　manipulated　when　they　　

are　passed　via　a　method。　Suppose　you　create　a　method　that　has　as　parameters　a　value　type　and　　

a　reference　type。　If　in　the　method　the　parameters　are　modified；　what　modifications　does　the　　

caller　of　the　method　see？　Consider　the　following　code：　



Sub　Method（ByVal　value　As　MyValueType；　ByVal　reference　As　MyReferenceType）　

　　value。value　=　10　

　　reference。value　=　10　

End　Sub　



　　　　　The　caller　can　pass　in　instances　of　a　value　type　and　a　reference　type　that　are　manipulated　　

in　the　context　of　the　method。　Now　let’s　call　Method（）　with　the　following　code：　


…………………………………………………………Page　108……………………………………………………………

86　　　　　　　　CH　AP　T　E　R　　　4　　　■　　　　L　E　A　R　N　IN　G　　　AB　OU　T　　　D　AT　A　　S　TR　U　CT　U　R　E　S；　　　DE　CI　SI　ON　S；　　　A　N　D　　　L　O　OP　S　



　　　　　　　　　　　Dim　value　As　MyValueType　=　New　MyValueType（）　

　　　　　　　　　　　Dim　reference　As　MyReferenceType　=　New　MyReferenceType（）　

　　　　　　　　　　　Method（value；　reference）　

　　　　　　　　　　　Console。WriteLine（〃value　value=〃　&　value。value　&　_　

　　　　　　　　　　　　　　　〃　reference　value=〃　&　reference。value）　



　　　　　　　　　　　　　　　　The　calling　code　instantiates　the　types　MyValueType　and　MyReferenceType；　calls　the　method　　

　　　　　　　　　　　Method（）；　and　then　inspects　the　value　of　the　data　member　value　from　the　value　and　reference　　

　　　　　　　　　　　types。　

　　　　　　　　　　　　　　　　Running　the　code　will　generate　output　similar　to　the　following：　



　　　　　　　　　　　value　value=0　reference　value=10　



　　　　　　　　　　　　　　　　The　executed　code　shows　that　the　value　type　（MyValueType）　data　member　was　not　altered；　　

　　　　　　　　　　　whereas　the　reference　type　（MyReferenceType）　data　member　was　altered。　This　is　correct；　and　it　　

　　　　　　　　　　　demonstrates　that　when　you　call　a　method；　you　are　assigning　the　parameters　of　the　method　to　　

　　　　　　　　　　　variables　in　the　ca