blocks|key|1471712|text|静态类型转换有不同的语法，再加上你需要使用指针，你想要做的是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1471713|unsigned+short+*myShort+=+static_cast<unsigned+short*>(&packetBuffer[1]);|code-block|syntax|javascript|1471714|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

static cast has a different syntax, plus you need to work with pointers, what you want to do is:

<pre><code>unsigned short *myShort = static_cast&lt;unsigned short*&gt;(&amp;packetBuffer[1]);
</code></pre>

blocks|key|1471794|text|这可能远远低于您所关心的，但请记住，这样做很容易获得未对齐的访问。x86是容错的，未对齐访问导致的中止将在内部捕获，并最终得到值的副本和返回值，因此您的应用程序不会知道任何不同之处(尽管它比对齐访问慢得多)。但是，如果这段代码将在非x86平台上运行(您没有提到目标平台，所以我假设是x86桌面Windows)，那么这样做将导致处理器数据中止，并且在尝试强制转换数据之前，您必须手动将数据复制到对齐的地址。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1471795|简而言之，如果您要经常进行这种访问，您可能会考虑对代码进行调整，以避免未对齐的读取，您将看到性能上的好处。|1471796|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

This is probably well below what you care about, but keep in mind that you could easily get an unaligned access doing this. x86 is forgiving and the abort that the unaligned access causes will be caught internally and will end up with a copy and return of the value so your app won't know any different (though it's significantly slower than an aligned access). If, however, this code will run on a non-x86 (you don't mention the target platform, so I'm assuming x86 desktop Windows), then doing this will cause a processor data abort and you'll have to manually copy the data to an aligned address before trying to cast it.

In short, if you're going to be doing this access a lot, you might look at making adjustments to the code so as not to have unaligned reads and you'll see a perfromance benefit.

blocks|key|1471845|text|不应该将无符号字符指针转换为无符号短指针(就此而言，从较小数据类型的指针转换为较大数据类型)。这是因为假设地址将正确对齐。一种更好的方法是将字节转换为真正的无符号短对象，或将memcpy转换为无符号短数组。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1471846|毫无疑问，您可以调整编译器设置来绕过这个限制，但这是一个非常微妙的事情，如果代码被传递和重用，它将在将来被破坏。|1471847|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

You should not cast a unsigned char pointer into an unsigned short pointer (for that matter cast from a pointer of smaller data type to a larger data type). This is because it is assumed that the address will be aligned correctly. A better approach is to shift the bytes into a real unsigned short object, or memcpy to a unsigned short array.

No doubt, you can adjust the compiler settings to get around this limitation, but this is a very subtle thing that will break in the future if the code gets passed around and reused.

blocks|key|1687072|text|那么，您正在将char加宽为一个短值。您想要的是将两个字节解释为短字节。static_cast无法从unsigned+char*强制转换为unsigned+short*。您必须先转换为void*，然后转换为unsigned+short*|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1687073|unsigned+short+*p+=+static_cast<unsigned+short*>(static_cast<void*>(&packetBuffer[1]));|code-block|syntax|javascript|1687074|现在，您可以取消引用p并获得短值。但这种方法的问题是，您从unsigned+char*转换为void*，然后转换为某些不同的类型。该标准并不保证地址保持不变(此外，取消引用该指针将是未定义的行为)。一种更好的方法是使用位移位，它总是有效的：|1687075|unsigned+short+p+=+(packetBuffer[1]+<<+8)+%7C+packetBuffer[2];|1687076|entityMap^0|10|B|1E|E|1X|F|2K|5|2V|F|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]|$9|T|A|U|B|C]|$9|V|A|W|B|C]|$9|X|A|Y|B|C]|$9|Z|A|10|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|11|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|12|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|13|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|14|8|@]|D|@]|E|$]]]|P|$]]

Well, you are widening the char into a short value. What you want is to interpret two bytes as an short. <code>static_cast</code> cannot cast from <code>unsigned char*</code> to <code>unsigned short*</code>. You have to cast to <code>void*</code>, then to <code>unsigned short*</code>:

<pre><code>unsigned short *p = static_cast&lt;unsigned short*&gt;(static_cast&lt;void*&gt;(&amp;packetBuffer[1]));
</code></pre>

Now, you can dereference p and get the short value. But the problem with this approach is that you cast from unsigned char*, to void* and then to some different type. The Standard doesn't guarantee the address remains the same (and in addition, dereferencing that pointer would be undefined behavior). A better approach is to use bit-shifting, which will always work:

<pre><code>unsigned short p = (packetBuffer[1] &lt;&lt; 8) | packetBuffer[2];
</code></pre>

blocks|key|1687080|text|unsigned+short+myShort+=+*(unsigned+short+*)&packetBuffer[1];|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1687081|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>unsigned short myShort = *(unsigned short *)&amp;packetBuffer[1];
</code></pre>

blocks|key|1687137|text|没有人看到输入是一个字符串吗！|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1687138|/*+If+it+is+a+string+as+explicitly+stated+in+the+question.
+*/
int+byte1+=+packetBuffer[1]+-+'0';+//+convert+1st+byte+from+char+to+number.
int+byte2+=+packetBuffer[2]+-+'0';

unsigned+short+result+=+(byte1+*+256)+%2B+byte2;

/*+Alternatively+if+is+an+array+of+bytes.
+*/
int+byte1+=+packetBuffer[1];
int+byte2+=+packetBuffer[2];

unsigned+short+result+=+(byte1+*+256)+%2B+byte2;|code-block|syntax|javascript|1687139|这也避免了大多数其他解决方案在某些平台上可能存在的对齐问题。注意:短字符至少是两个字节。如果你尝试去引用一个不是2字节对齐的短指针(或者不管你系统上的大小是多少)，大多数系统都会给你一个内存错误！|1687140|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Did nobody see the input was a string!

<pre><code>/* If it is a string as explicitly stated in the question.
 */
int byte1 = packetBuffer[1] - '0'; // convert 1st byte from char to number.
int byte2 = packetBuffer[2] - '0';

unsigned short result = (byte1 * 256) + byte2;

/* Alternatively if is an array of bytes.
 */
int byte1 = packetBuffer[1];
int byte2 = packetBuffer[2];

unsigned short result = (byte1 * 256) + byte2;
</code></pre>

This also avoids the problems with alignment that most of the other solutions may have on certain platforms. Note A short is at least two bytes. Most systems will give you a memory error if you try and de-reference a short pointer that is not 2 byte aligned (or whatever the sizeof(short) on your system is)!

blocks|key|1687224|text|char+packetBuffer[]+=+{1,+2,+3};
unsigned+short+myShort+=+*+reinterpret_cast<unsigned+short*>(&packetBuffer[1]);|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1687225|我(不得不)一直这样做。big+endian是一个显而易见的问题。当机器不喜欢未对齐的读取时，真正会得到的是不正确的数据！(和编写)。|unstyled|1687226|您可能想要编写一个测试类型转换和一个断言，以查看它是否可以正确读取。因此，当在大端机器上运行时，或者更重要的是，在不喜欢未对齐读取的机器上运行时，将发生断言错误，而不是奇怪的难以跟踪的'bug‘;)|1687227|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|L|8|@]|9|@]|A|$]]|$1|G|3|H|5|F|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|F|7|N|8|@]|9|@]|A|$]]]|J|$]]

<pre><code>char packetBuffer[] = {1, 2, 3};
unsigned short myShort = * reinterpret_cast&lt;unsigned short*&gt;(&amp;packetBuffer[1]);
</code></pre>

I (had to) do this all the time. big endian is an obvious problem. What really will get you is incorrect data when the machine dislike misaligned reads! (and write).

you may want to write a test cast and an assert to see if it reads properly. So when ran on a big endian machine or more importantly a machine that dislikes misaligned reads an assert error will occur instead of a weird hard to trace 'bug' ;)

blocks|key|1472125|text|在windows上，您可以使用：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1472126|unsigned+short+i+=+MAKEWORD(lowbyte,hibyte);|code-block|syntax|javascript|1472127|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

On windows you can use:

<pre><code>unsigned short i = MAKEWORD(lowbyte,hibyte);
</code></pre>

blocks|key|1472179|text|也许这是一个很晚的解决方案，但我只想和你分享。当您想要转换基元或其他类型时，您可以使用联合。如下所示：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1472180|union+CharToStruct+{
++++char+charArray[2];
++++unsigned+short+value;
};


short+toShort(char*+value){
++++CharToStruct+cs;
++++cs.charArray[0]+=+value[1];+//+most+significant+bit+of+short+is+not+first+bit+of+char+array
++++cs.charArray[1]+=+value[0];
++++return+cs.value;
}|code-block|syntax|javascript|1472181|当您创建一个十六进制值以下的数组并调用toShort函数时，您将得到一个带有3的短值。|1472182|char+array[2];+
array[0]+=+0x00;
array[1]+=+0x03;
short+i+=+toShort(array);
cout+<<+i+<<+endl;+//+or+printf("%25h",+i);|1472183|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Maybe this is a very late solution but i just want to share with you. When you want to convert primitives or other types you can use union. See below:

<pre><code>union CharToStruct {
 char charArray[2];
 unsigned short value;
};


short toShort(char* value){
 CharToStruct cs;
 cs.charArray[0] = value[1]; // most significant bit of short is not first bit of char array
 cs.charArray[1] = value[0];
 return cs.value;
}
</code></pre>

When you create an array with below hex values and call toShort function, you will get a short value with 3.

<pre><code>char array[2]; 
array[0] = 0x00;
array[1] = 0x03;
short i = toShort(array);
cout &lt;&lt; i &lt;&lt; endl; // or printf("%h", i);
</code></pre>

I have been working on a legacy C++ application and am definitely outside of my comfort-zone (a good thing). I was wondering if anyone out there would be so kind as to give me a few pointers (pun intended).

I need to cast 2 bytes in an unsigned char array to an unsigned short. The bytes are consecutive. 

For an example of what I am trying to do:

I receive a string from a socket and place it in an unsigned char array. I can ignore the first byte and then the next 2 bytes should be converted to an unsigned char. This will be on windows only so there are no Big/Little Endian issues (that I am aware of).

Here is what I have now (not working obviously):

<pre><code>//packetBuffer is an unsigned char array containing the string "123456789" for testing
//I need to convert bytes 2 and 3 into the short, 2 being the most significant byte
//so I would expect to get 515 (2*256 + 3) instead all the code I have tried gives me
//either errors or 2 (only converting one byte
unsigned short myShort;
myShort = static_cast&lt;unsigned_short&gt;(packetBuffer[1])
</code></pre>

C++: how to cast 2 bytes in an array to an unsigned short

大数据

编译器

Windows

我一直在开发一个遗留的C++应用程序，这绝对超出了我的舒适区(这是一件好事)。我想知道有没有人愿意给我一些建议(双关语)。我需要将无符号字符数组中的2个字节转换为无符号短整型。字节是连续的。下面是我想要做的一个例子：我从套接字接收一个字符串，并将其放在一个无符号字符数组中。我可以忽略第一个字节，然后将接下来的两个字节转...

问C++：如何将数组中的2个字节转换为无符号短整型
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问C++：如何将数组中的2个字节转换为无符号短整型EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问C++：如何将数组中的2个字节转换为无符号短整型
EN