Visual Basic 中的字节函数

问题描述 投票:0回答:1

为什么VB表达式

Asc(ChrB(128) & ChrB(0))

产量 63 而不是 128?

最近,我一直在研究 Visual Basic 的 InputB 函数来读取二进制数据。根据帮助系统,这些 B 后缀的函数用于文本文件和字符串中的“字节数据”。

在VB中,字符串中的单个字符占用的不是一个字节而是两个字节。例如,函数调用

Input(1, #fnum)
返回一个两字节字符串。然而,相比之下,
InputB(1, #fnum)
返回一个单字节字符串(或“半个”字符)。

传统 ASCII / ANSI 字符包含在单个字节内。如果您使用

InputB(1, #fnum)
将 ASCII / ANSI 字符读入字符串字符的前“半部分”,并使用
ChrB(0)
用“零”字节填充后半部分,那么理所当然地,结果是两个字节字符将与使用普通
Input(1, #fnum)
获得的结果相同。

事实上,这很大程度上就是所发生的情况。只有当您输入某些字符代码(例如 128)时,事情才会出错。 例如,考虑以下代码。为了避免所有文件处理代码,我使用

AscB

代替 InputB Dim c1 As Integer Dim c2 As Integer Dim i As Integer Debug.Print "Code #1", "Code #2" For i = 0 To 255 c1 = Asc(Chr(i)) c2 = Asc(ChrB(i) & ChrB(0)) Debug.Print c1, c2 Next i

输出如下。

一切顺利,直到达到 128。从那里到 159,

c1

c2
有时如预期相同,但有时则不同。如果不是,
c2
始终为 63。从 160 向上,输出再次表现良好。
Code #1       Code #2
 0             0 
 1             1 
 2             2 
 3             3 
 4             4 
 5             5 
 6             6 
 7             7 
 8             8 
 9             9 
 10            10 
 11            11 
 12            12 
 13            13 
 14            14 
 15            15 
 16            16 
 17            17 
 18            18 
 19            19 
 20            20 
 21            21 
 22            22 
 23            23 
 24            24 
 25            25 
 26            26 
 27            27 
 28            28 
 29            29 
 30            30 
 31            31 
 32            32 
 33            33 
 34            34 
 35            35 
 36            36 
 37            37 
 38            38 
 39            39 
 40            40 
 41            41 
 42            42 
 43            43 
 44            44 
 45            45 
 46            46 
 47            47 
 48            48 
 49            49 
 50            50 
 51            51 
 52            52 
 53            53 
 54            54 
 55            55 
 56            56 
 57            57 
 58            58 
 59            59 
 60            60 
 61            61 
 62            62 
 63            63 
 64            64 
 65            65 
 66            66 
 67            67 
 68            68 
 69            69 
 70            70 
 71            71 
 72            72 
 73            73 
 74            74 
 75            75 
 76            76 
 77            77 
 78            78 
 79            79 
 80            80 
 81            81 
 82            82 
 83            83 
 84            84 
 85            85 
 86            86 
 87            87 
 88            88 
 89            89 
 90            90 
 91            91 
 92            92 
 93            93 
 94            94 
 95            95 
 96            96 
 97            97 
 98            98 
 99            99 
 100           100 
 101           101 
 102           102 
 103           103 
 104           104 
 105           105 
 106           106 
 107           107 
 108           108 
 109           109 
 110           110 
 111           111 
 112           112 
 113           113 
 114           114 
 115           115 
 116           116 
 117           117 
 118           118 
 119           119 
 120           120 
 121           121 
 122           122 
 123           123 
 124           124 
 125           125 
 126           126 
 127           127
 128           63 
 129           129 
 130           63 
 131           63 
 132           63 
 133           63 
 134           63 
 135           63 
 136           63 
 137           63 
 138           63 
 139           63 
 140           63 
 141           141 
 142           63 
 143           143 
 144           144 
 145           63 
 146           63 
 147           63 
 148           63 
 149           63 
 150           63 
 151           63 
 152           63 
 153           63 
 154           63 
 155           63 
 156           63 
 157           157 
 158           63 
 159           63 
 160           160 
 161           161 
 162           162 
 163           163 
 164           164 
 165           165 
 166           166 
 167           167 
 168           168 
 169           169 
 170           170 
 171           171 
 172           172 
 173           173 
 174           174 
 175           175 
 176           176 
 177           177 
 178           178 
 179           179 
 180           180 
 181           181 
 182           182 
 183           183 
 184           184 
 185           185 
 186           186 
 187           187 
 188           188 
 189           189 
 190           190 
 191           191 
 192           192 
 193           193 
 194           194 
 195           195 
 196           196 
 197           197 
 198           198 
 199           199 
 200           200 
 201           201 
 202           202 
 203           203 
 204           204 
 205           205 
 206           206 
 207           207 
 208           208 
 209           209 
 210           210 
 211           211 
 212           212 
 213           213 
 214           214 
 215           215 
 216           216 
 217           217 
 218           218 
 219           219 
 220           220 
 221           221 
 222           222 
 223           223 
 224           224 
 225           225 
 226           226 
 227           227 
 228           228 
 229           229 
 230           230 
 231           231 
 232           232 
 233           233 
 234           234 
 235           235 
 236           236 
 237           237 
 238           238 
 239           239 
 240           240 
 241           241 
 242           242 
 243           243 
 244           244 
 245           245 
 246           246 
 247           247 
 248           248 
 249           249 
 250           250 
 251           251 
 252           252 
 253           253 
 254           254 
 255           255

	
vba
1个回答
0
投票

在VB中,字符串中的单个字符占用的不是一个字节而是两个字节。例如,函数调用 Input(1, #fnum) 返回一个两字节字符串。然而,相比之下,InputB(1, #fnum) 返回一个单字节字符串(或“半个”字符)。

传统的 ASCII / ANSI 字符包含在单个字节内。如果您使用 InputB(1, #fnum) 将 ASCII / ANSI 字符读入字符串字符的前“半部分”,并使用 ChrB(0) 用“零”字节填充后半部分,那么应该有理由认为生成的两字节字符将与使用普通 Input(1, #fnum) 获得的结果相同。

您的理解存在一些缺陷。

但是,InputB(1, #fnum) 返回一个单字节字符串(或“半个”字符)。

这不准确。它返回一个完整的字符。它查看两字节字符,为您提供完整的 ascii 字符等效项,该字符现在仅占用一个字节。这仍然是一个完整的字符,而不是“一半”字符,但编码不同。

如果您使用 InputB(1, #fnum) 将 ASCII / ANSI 字符读入字符串字符的前“半部分”

再次强调:你会得到一个完整的角色。

将 ASCII / ANSI 字符读入字符串字符的前“半部分”,并使用 ChrB(0) 用“零”字节填充后半部分,那么按理说,生成的两字节字符将与使用普通 Input(1, #fnum) 代替获得的结果。

那是
向后

。两个字节字符的前导部分为 0,ascii 值位于尾随部分。


现在我们可以看看这个表达式:

Asc(ChrB(128) & ChrB(0))

这需要两个完整的单字节字符(值 128 和 0)并将它们连接在一起形成一个 
two-character

字符串。然后调用 Asc() 函数。

Asc()
函数查看字符串中的第一个字符,其值为 128。

128

没有ascii字符,因此按照惯例,您会得到一个问号(?),即ascii值63。

    

© www.soinside.com 2019 - 2024. All rights reserved.