Zkopírování části paměti - memcpy – C / C++ – Fórum – Programujte.com

LSB je int. buf je char *. Potřebuji do buf nakopírovat 4 byty z LSB (z leva doprava). Zkouším dvě možnosti:
 

1)
buf[0] |= LSB & 0xFF000000;
buf[1] |= LSB & 0x00FF0000;
buf[2] |= LSB & 0x0000FF00;
buf[3] |= LSB & 0x000000FF;
nic to nedělá
2)
memcpy(buf, (int) &LSB, 4); // přepiš 3 byty od konce

taky nic to nedělá

buf: 0x22e864 "Aenean."

LSB: 196611

Když vymažu operátor & u memcopy tak mám hlášení: makes pointer from integer without a cast [enabled by default]| include\string.h|38|note: expected 'const void *' but argument is of type 'int'| Přímo LSB jako source tam dát nemohu, to by krachlo. Co s tím?
 

#1 oxidián

varianta jedna nic nekopiruje (operator |= neni kopie), krom toho se ti vysledek u 3 ze 4 osekne na jeden byte, takze vzdy budes delat or s 0 coz je puvodni hodnota. Nejmene u toho na indexu 3 bych cekal mensi zmenu.

Varianta dve by mohla i fungovat, ale bude zalezet na byte orderu. Na vetsine oblibenych procesoru bude prvni LSB (little endian). A podle prvni varianty hadam, ze to bude presne obracene.

Operace mecpy ale ani nevymaže ty data, takže se nekopíruje nic. Ten původní řetězec zůstal nedotčený.
 

Ani toto nedělá změnu:

buf[0] |= LSB & 0xFF000000 ;
buf[1] |= LSB & 0x00FF0000 << 8;
buf[2] |= LSB & 0x0000FF00 << 16;
buf[3] |= LSB & 0x000000FF << 24;

#3 oxidián
 

#include <stdio.h>
#include <string.h>

int main() 
{
	unsigned char  buf[] = "Aenenan";
	unsigned int   lsb   = 196611;

	for (int i=0; i<7; ++i) printf("%d '%c';", buf[i], buf[i]);
	printf("\n");

	memcpy(buf, &lsb, 4);

	for (int i=0; i<7; ++i) printf("%d '%c';", buf[i], buf[i]);
	printf("\n");
}

Vysledek:

./a.out 
65 'A';101 'e';110 'n';101 'e';110 'n';97 'a';110 'n';
3 '';0 '';3 '';0 '';110 'n';97 'a';110 'n';

Takze evidentne funguje.

Taktez to same vyflusne:

*((unsigned int*)buf) = lsb;

Pokud bys to chtel v opacnem poradi, tak nejake funkce pro endianitu z <endian.h>.

A pak je jeste spousta dalsich moznosti:

    buf[0] = lsb >> 24;
    buf[1] = lsb >> 16;
    buf[2] = lsb >> 8;
    buf[3] = lsb;

To uz vyflusne:

0 '';3 '';0 '';3 '';110 'n';97 'a';110 'n';

Já už vím co mám špatně (částečně). Já nemám pracovat přímo s buf ale s pointerem s ukazujícím na buf

char * s, *pEnd, *pStart, *pMSB2start, *pLSB16start;
pEnd = buf + bufLen - 1; // pEnd is +1B out of buffer!
pMSB2start = pEnd;
pLSB16start = pEnd - 3; // -3B ; 2b * 12 = 24b = 3B
s = pLSB16start;

...

s -= 4; // set pointer

memcpy(s, &LSB, 4);

s before: 0x22e864 "Aenean."

s after: 0x22e864 "�03"

// s: 0x22e864 "Aenean."
s[0] = LSB << 24;
s[1] = LSB << 16;
s[2] = LSB << 8;
s[3] = LSB;

můj výsledek:

s[0] = \000

s[1] = \000

s[2] = \000

s[2] = \003

což vypadá že se někam vytratili ty dvě binární 11 na začátku (zleva) LSB

tak asi ten kod není dobře

ale toto funguje:

*((unsigned int*)s) = LSB;

výsledek:

3 '\003'
0 '\000'
3 '\003'
0 '\000'

Ještě potřebuju vyřešit jednu věc s tím LSB,

m[i] = 0b000000110000000000000011; // 196609

m[i+1] = 0b000000110000000000000011; // 196609
LSB = 0;
LSB |= m[i] & ~0xFFFF0000 << 16; // 16 bits LSB
LSB <<= 16;
LSB |= m[i+1] & ~0xFFFF0000; // tady se má zkopírovat jen 2 byty zprava, aby se nepřepsalo to co jsem zkopíroval a posunul výše.

Jak opravit ten poslední řádek aby se zkopírovaly jen 2 byty neboli 16bitů? Jde o to zachovat 16 bitů MSB a zkopírovat tam 16 bitů zprava.

Pro tom prvním posunu se z čísla 3 stane binárně

11000000 00000000 00

a po druhém nakopírování by tam mělo být

11000000 00000000 11

teda správně rozděleno by to bylo takto:

   |-> dalších 16 bitů

11 00000000 00000000

11 00000000 00000011

#6 oxidián
na to, aby se ti dalo odpovedet, bych musel vedet, jakeho typu jsou m, LSB.

Proc napriklad delas  ~0xFFFF0000, kdyz rovnou muzes zapsat 0xFFFF (respektive 0xFFFFU, aby to bylo bez znamenka). No a kdyz to pak jeste posunes o 16, tak vlastne zbyde zase  0xFFFF0000. No a tim pak vymaskujes to m[i].

// priklad:

unsigned int  val =  0xDEADBEEFU;

printf("0x%08x\n", (val & ~0xFFFF0000U) << 16); // prints: 0xbeef0000
printf("0x%08x\n", val & ~0xFFFF0000U << 16);   // prints: 0xdead0000

unsigned int m[12];

unsigned int LSB = 0;

Tak asi to má být takto:

LSB = 0;
LSB |= m[i] & 0xFFFFU << 16; // 16 bits LSB
LSB |= m[i+1] & 0xFFFFU;

A hle, ono to funguje! Tak dík.

Druhý řádek nastaví LSB: 196608

třetí řádek LSB: 196611

A dále v kódu pak s je:

s[0] = 3 '\003'

s[1] = 0 '\000'

s[2] = 3 '\003'

s[3] = 0 '\000'

#8 oxidián
 

LSB  = m[i] & 0xFFFF0000u; // to je to co tam ted mas na druhem radku
LSB |= m[i+1] & 0xFFFFu;   // urcite neprepise nic nad 16. bit, jelikoz se tam nemuze vyskytnout zadna logicka jednicka.

#9 KIIV
"m[i+1] & 0xFFFFu; // urcite neprepise nic nad 16. bit, jelikoz se tam nemuze vyskytnout zadna logicka jednicka"

OK. To dává smysl. Takže když říkáš "nad 16. bit" to tedy v programátorské hantýrce znamená směrem od LSB k MSB, chápu to správně?

#10 oxidián
LSB je nejmene platny bit s vahou 2^0 = 1 (je to klasicka pozicni soustava). Dalsi bit ma pozici 1, tj. 2^1 = 2

Pokud chces vedet dekadickou hosnotu nejakeho cisla, tak to funguje nasledovne:

0b1000101 =>  1 * 2^6  +  0 * 2^5  +  0 * 2^4  +  0 * 2^3  +  1 * 2^2  +  0 * 2^1  +  1 * 2^0 => 64 + 4 + 1 = 69

Jak jsi asi pochopil, tak se v pozicnich soustavach pocitaji pozice od desetinne carky (z prava do leva), za desetinnou carkou jsou pak zaporne.  0b0,1  by pak bylo:  1 * 2^(-1)   =   0.5 dekadicky

A tak jo, já jsem se to kdysi učil ty různé soustavy a rozebírání čísel. Myslím že jsem to ještě nezapomněl.

#12 oxidián
ja jen proc je to v programatorske hantyrce od LSB po MSB. Podobne muzu vysvetlit or a and, booleovy zakony, ...

Radši ne. Dík. Já se to kdysi učil, ale paměť to víš, časem se to vykouří jak to člověk málo používá nebo nepoužívá.

memcpy(buf, (int) &LSB, 4); // přepiš 3 byty od konce

šílenej guláš. Získáš ukazatel, ten přetypuješ na int a cpeš ho jako parametr funkci memcpy, která chce ukazatel. Navíc podle třetího parametru memcpy se kopírují 4 Byty.

Nebylo by od věci rozepsat si všechno do jednotlivých řádků a krokovat v debuggeru a dívat se na hodnoty proměnných.

Pochybuji, že by z tebe mohl být alespoň průměrný lepič kódu (jako jsem já) když ses do teď nenaučil ani základní věci probírané v kdejakém tutoriálu. Za dobu, kterou sem na fórum chodíš, jsem dokázal sestavit "woknovou" aplikaci, která četla z COMu, zobrazovala průběžně hodnoty a ukládala je do souboru. Nebylo to kdovíjak učesané, ale fungovalo to spolehlivě. Co vše umí WinAPI nebo co je objektové programování jsem ještě nevěděl, ale používání datových typů a ukazatelů jsem znal.

hu

Jsou to tvoje pochyby ne moje. Za dobu co jsem chodím jsem se věnoval třem, respektive čtyřem jazykům. Céčko jsem skoro úplně zapomněl, takže je to jako bych začal právě teď.  Ale neboj já si zase rozpomenu.