I'm trying to write a program that writes data to a disk in C++ without caring about it's file system. Here is what I can do so far:
#include <iostream>
#include <unistd.h>
#include <fcntl.h>
using namespace std;
char buffer[] = "Wow! I'm writing this data to a disk without puttting it into a file!";
int main(){
int Disk=open("/dev/sdb",O_RDWR);
write(Disk,buffer,sizeof(buffer));
close(Disk);
return 0;}
But this program can only write ASCII characters to the disk. But what if I want to mainipulate bits on the disk, how would I do that?
I am working on a project where I need to retrive a double number and store 8 bits of the number in one field and the other 16 bits in another field. the code below gives me an error.
lata= lat>>8; latb = (lat & 0xff);
The error states that & and >> are illegal for double. With this in mind, can I use these on a double. If not what can I do to achieve what I am trying to do?
Any algorithm or function to rotate a displayed circle. To turn it 360 degrees like a car-tire. (It's needed to turn a turn-table in a model-railrod control program) .....
When we are using RAM DISK - the files are stored on the RAM. From what I understand (and saw many examples) in order to read data from file (the file which locate on the RAM) - I need to use the read function.
Is there a chance to get char* (or any pointer) to the content of the file without using the read function ?
If the file locate on the RAM, it seem that it is like I have a buffer on the RAM (like an array which was dynamic allocated) and in the case of a buffer on the ram -> we can use pointers to the data without reading all the data.
example:
class CDATA { int nValue1; int nValue2; double dValue3; double dValue4; char achBuf[10];
So this code compiles without any problem but it is not producing the correct output. I know there's a problem in either my getBlock or putBlock functions but I can't see it.
Currently the output is "Should be 32 1s: " "Should be 32 2s: "
There should be 32 1s and 32 2s and nothing is coming out.
#include <iostream> #include <fstream> using namespace std; class Sdisk { public : Sdisk(string diskname);
I am using Visual C++ to write an app. One problem is that the application will allocate a lot of object instances of a specific class CMyObject, maybe 400, 000. This will cause "Out of memory" error when total allocated CMyObject reaches 400,000.
To solve this problem, I just wonder when a new CMyObject instance is created, is it possible to specify so that the instance will allocate on a disk cache, or file mapping instead of the memory space?
I made a text file. I can do all File I/O functions in c. no problem! except that "I want to get the memory address of the beginning of that File", so that I can access each character of the file by incrementing memory address.
Basically, I want to write an image to disk in parallel with an algorithm that is processing that same image. The code is really simple:
Code: string ProcessImage(System::Drawing::Bitmap ^bmp, System::String^ targetFile) { bmp->Save(targetFile); System::Drawing::Bitmap^ bmp8 = BitmapConvertPixelFormat(bmp, 8); //<-- a function I wrote which converts the 32bpp I am passed into an 8bpp one string results = Analyze(bmp8); //<--- takes a good bit of time return results; }
What would be the fastest way to do this? Any libraries with a code sample. I would prefer one that is within .NET or native C++ just to avoid having to link into many different libraries.
This directory "H:C" does exist, if I comment out the GetDiskFreeSpaceExA line, the program doesn't crash, but it leads to some peculiar results (some uninitialized and random value, but at least it doesn't crash)
Here is a working C++ program and its output that reads the names of a certain number of functions whose names are written in a disk file that provides the control parameters in a near-real time fashion. Based on this information, the program calls those functions whose names were given in this text file as parameters. The method I have used is to build a map of functions that connects the names of the functions to the actual functions. Once this map is created, then it is very easy to iterate in such a way that only those selected functions are called.
So far this is working well, and it makes the logic of the code easier because ultimately there will be a large inventory of functions (probably hundreds of functions), and this way of pre-building a map of functions avoids writing hundreds of if statements in the code. Of course, pre-building this reusable map in the background is still equivalent to writing that many if statements, but at least it makes the code very compact and much more automatic, since it is done only once.
But I now have a related question: In this case (when the selected subset of functions to call is given as incoming data as in this example), does C++ make it possible to avoid using maps of functions, by directly applying the string variable that holds the name of the function in order to call the original function immediately For instance, if a string variable s = "MyFunction", then is there a more direct way of using this string as if it were the actual function whose name is spelled exactly in that way? This would make the code even more compact.
Here is the sample test code for the map of functions, and its output:
First of all here is the text file "FileForNamesOfFunctions.TXT" that contains the part of the "data", which is the set of functions select from from the inventory and only call these:
Code: function2 function3 function5 And here is the C++ code that uses this "data":
Opening large files in c++. In my application, i am trying to save video as long as users have space in harddisk. What I am trying to do is when user is recording video i am trying to append the video data in to the file. The problem is that every time file size reach over 2GB my software crashes.
I am having a problem assigning bits a value of 0. The data is a 16 bit integer the bits greater than the 12th bit have garbage either a 0 or a 1. I would like to assign all bits greater than 12th bit the value 0 no matter what their values are. Whats the best approach.
Using the old fashioned (unsigned) multiplication instruction in x64 assembly multiplies RAX (64 bit register) by a 64 bit register. The answer is stored in RDX:RAX (i.e. the answer is 128 bits). Is there any way, using native c++ to get the value in RDX (higher 64 bits)? One I can think of is: right/(limit/left) e.g. if we are limited to a byte then 97*123 would overflow:
97/(255/123) = 46 times, which is RDX's (if it was one byte) value. But this is too inefficient. Is there a fast way?
If we use bitwise-shift to shift all bits to the right by 2, x is 0:
00000000000000000000000000000000
If we then do a bitwise leftshift on x by 30, do we end up with:
11000000000000000000000000000000 or 00000000000000000000000000000000
In other words, when we perform right shift which clips away the least most significant bits, and then do a left shift, is it possible for those bits to reappear?
I am trying to retrieve the first three bits of a number. The code that I am using should work but it isn't giving me the correct result when trying certain numbers. Below is the code I am using:
unsigned short num1, num2 = 0; unsigned short num = 65535// binary 111111111111111 num1 = num && 0x07;// gives me 1 but should give 7(111) num2 = num >>3;//gives me 8191, which is correct
Why I am not getting the first three correct bits(111)?
I have a double variable and depending on certain conditions I need to set certain bits of an unsigned short Variable. For example, if double var is odd I need to set the 15th bit of the unsigned short variable.
I am trying to encrypt a plaintext using DES in C. I read about the algorithm and how it works, but when i came to write the code i struggled. :
How to locate the lowest 8-bits in a 64-bit key ?
How to shuffle the plaintext according to the algorithm description ? (I read about bitwise operations, but i still cannot understand how i can use them to transfer for example the 5th bit to the location of the 30th bit)
Left shifting the key would not wrap the bits, so i just bitwise or with a mask that will add the bits that did not wrap around?
I'm working on an assignment where I have to read an image in the PPM format. This format consists of a header that contains the parameters and the rest is raw bits.
I have to work with a modified PPM image that contains a secret message. This message is stored in the first X number of bytes. To decode a single character I would have to look at the lowest level bit of 8 bytes and return that as a character, then repeat this for the length of the message.
The code below is what I have so far, but I do not get the expected output but instead I get smiley-faces.... or other ASCII characters depending on the shift.
char buffer = 0; int MsgSize =(size*8); int nRead = 0; printf("The secret message is displayed below: "); for(i; i<MsgSize; i++) {
I just have a short question! I have an sbyte and I want to convert it to an int, but I do not want a value conversion, just to copy the bits, such that the negative numbers in the sbyte will be their complement in the int (-12 in sbyte -> 244 in int)... How can I do that?las
Code: Primitive<uint64_t> b = 0xCCCCCCCC00000000; I need to save the first 31 (most important) bits - 7FFFFFFE.
I found this solution in the Internet:
Code: start = (((b)>>(first)) & ((1<<(((last+1)-(first))))-1)); but in my case for this code: Code: Primitive<uint64_t> start = (((b)>>(32)) & ((1<<(((63+1)-(32))))-1));
I was trying to program an decimal to binary converter (8-bits) in C. I am a complete beginner so I tried to put the 1's and 0's of the binary number as they come without reversing the order for beginning. I have seen example on the internet but didn't understand them so I decided to write it as I understood it. So, I typed the code as shown below:
Code: #include <stdio.h> #include <stdlib.h> int main() { int number; int BitNum[8], x;
[Code] ....
The problem with the code is that if binary form has 0s in it then program displays a random number instead of a 0. For example if decimal is 7, it should print out 11100000 but it displays only 111(and some stupid numbers instead of 0). I have tried to solve it but failed.
So I'm supposed to write a code that asks a user for a string and then displays the hex, decimal, and binary code for each individual letter and then tells the user how many bits in binary were 1. For example: Enter a line of text: Hello
The ASCII code for 'H' is 0x48 in hex, 72 in decimal, or 01001000 in binary, 2 bits were set. The ASCII code for 'e' is 0x65 in hex, 101 in decimal, or 01100101 in binary, 4 bits were set. The ASCII code for 'l' is 0x6c in hex, 108 in decimal, or 01101100 in binary, 4 bits were set. The ASCII code for 'l' is 0x6c in hex, 108 in decimal, or 01101100 in binary, 4 bits were set. The ASCII code for 'o' is 0x6f in hex, 111 in decimal, or 01101111 in binary, 6 bits were set.
So far I've got a code that will display the binary bit pattern by shifting a mask and testing for a 1 or 0. The problem is I can't figure out how to make it so the 1's and 0's get put into a single integer rather than just printing out. I hope that makes sense. Here's my whole code.
Code:
#include<stdio.h> main () { int i; char input; printf ("Enter ........: "); scanf ("%c", &input); for (i = 1; i <= 8; i++)
