| |
| |
| |
|
Page: 1 2
Comments:
<0> LiquidObsidi: u have to define your own data structure
<1> There is no native 128 bit long type.
<2> how do you know frob?
<2> I bet there are 128 bit prrocessors out there
<3> herm .. how .. plz primepie , i'm not a wiizz programmer ^
<2> start bit slappin liquid
<3> bit slapping ?
<2> yes, slap the bits around on your own
<3> well , since i'll want to da a lotsa <<'ing i don't really want to check what'll be lost and saving it in another var before continuing anytime i'll operate on the var...
<3> noone know a lil workaround ?
<2> the workaround is called work
<3> ^^
<2> notice the word work right in there
<3> if i were'nt lazy i wouldn't be develloper ^^
<2> ok
<2> ***ume 32bit ints, define an array of 4 of em
<1> hammr - I know there isn't a 128 bit type because the language standard doesn't specify it.
<2> then write your own functions to xor and etc on the array
<2> get it?
<1> And although you can ***ume 32 bit ints on most systems, they are certainly not guarenteed.
<2> void xormyarray(int *thingy) {
<2> void xormyarray(int *thingy, int *thing to xor with) {
<1> There are system-specific constants you should use, such as CHAR_BITS to determine how big a char is.
<1> then you can use sizeof to determine how many ints it is.
<2> thingy[0]^=thingtoxorwith[0];
<3> yeah hammr , i already tought of this way , but since i saw that on some arch long double was 128bit long i'd like to know if it were possible to make gcc do like this on mine...
<1> Or, if you prefer the easier route, you CAN ***ume that a char is at least 8 bits, and create an array of chars.
<2> thingy[1]^=thingtoxorwith[1];
<2> I dont know your arch
<3> x86
<2> nor do I care to know it
<3> :p
<1> long double is a different animal, and the C standard doesn't guarentee that it is 128 bits.
<2> use what I wrote above
<3> well if there's no easier way , i'll do it this way
<1> sigh.
<1> You should use an array of chars.
<1> Not an array of ints.
<2> why?
<3> well frob any array of something that does 128 bit long in the end 2* unsigned long long int for instance will require less work ...
<3> somwhere arount 2 time less
<1> Whatever you want.
<3> that's crappy ... well i'll have to do the dirty job by hand ..;
<3> see yah..
<2> hand job
<3> ah ah ah
<2> start bit slappin
<1> The "less work" bothers me. THe work required is the same.
<0> why do u want to work with 128bit ?
<1> In fact, it might require more work for the CPU using the long long type, and it won't work on older or less compliant compilers.
<3> gotta make a kinda proof of concept for one of my course
<0> ah I see
<2> where are all the chicks in this room?
<3> frob , that wont run anywhere that on my laptop
<3> rofl
<0> if u can fiddle with bits, just allocate 16bytes to a variable and do whatever u want
<2> like bit slappin
<2> by had job
<2> bu hand job
<0> if this is what u call it, then yes :)
Return to
#c
or
Go to some related
logs:
VEN_11C1
.tofixed(1)
pyneighborhood mount
#linuxhelp
Prob1Random
#linuxhelp
#linux
naty
#MissKitten
error C2804: binary 'operator <<' has too many parameters
|
|