Kodowanie arytmetyczne - liczby zmiennoprzecinkowe

0

Mam problem z prawidłowym przypisaniem zmiennych z tablicy typu float do zmiennej typu float/double.
Wynik wychodzi z kosmosu jak by znajdowały się gdzieś śmieci, kod poniżej:

/////// ZNALEZIENIE PRZEDZIALU  ////////	
//cout<<ilosc_i<<endl;


for(i=0;i<ilosc_i;i++)
{	
cout<<"przedzial  : ";

for(j=0; j<=t-1; j++)
{
     cout<<" "<<sump[j];
     
     cout<<" -"<<znak[j]<<"-";
}

for(j=0;j<t; j++)
{	
cout<<"dul: "<<sump[j]<<" j+1 "<<sump[j+1]<<endl;
if(symbol==znak[j])
{ 
dol = sump[j];  // OD TEGO MIEJSCA ZACZYNAJĄ SIĘ CYRKI
gora = sump[j+1]; // Z GORY DZIEKI ZA POMOC

j = t;

}
}

sump[0] = dol;
sumppodany identyfikator nie istnieje = gora;
cout<<endl;
for(j=1; j<t; j++)
{
podstawa = gora-dol;
sump[j] = sump[j-1] + prawd[j-1]*podstawa;

}

} 
0

We wskazanym przez ciebie miejscu mogą zacząć się cyrki tylko z kilku powodów:

  1. rozmiar tablicy sump jest mniejszy niż t
  2. dol ma niewłaściwy typ
  3. tablica sump wskazuje na zwolnione miejsce na stosie coś w rodzaju double *fun() { double tb[10]; ... return tb; }
    Obstawiałbym to trzecie.
0

Dzięki za odpowiedź. Też mi się wydaje, że to jest trzeci problem, jednak nie wiem jak go ominąć, wyjaśnisz ?

0

np tak:

vector<double> fun() { vector<double> tb(10); return tb; }
0

Zrobiłem jak poniżej, niestety nie rozwiązało to problemu.

nadal otrzymuje taki wynik: user image
Czy dobrze ustawiłem vector ?

 	vector <float> prawd(1000);
	vector <float> sump(1000);
	float tab[1000];
	float tab1[1000];
	float dol ;
	float gora;
	float podstawa;
	float prawdo;
	for(i=0; i<t-1;i++)
	{
		
				
		tab1[i] = ilosc[i]/ilosc_i;
		cout<<znak[i]<<" "<<tab1[i]<<endl;
	}
	
	
	sump[0] = 0;
	for(i=0; i<t;i++)
	{
		
		
		tab[i+1] = tab[i] + tab1[i];
		
	}
	

	
	for(i=0; i<t;i++)
	{
		sump[i]=tab[i];
		prawd[i]=tab1[i];
		cout<<"  "<<tab[i]<<" ";
	}
	cout<<endl;
	/////// ZNALEZIENIE PRZEDZIALU  ////////	
	//cout<<ilosc_i<<endl;

	for(i=0;i<ilosc_i;i++)
	{	
		cout<<"przedzial  : ";
		
		for(j=0; j<=t-1; j++)
				{
			     	cout<<" "<<sump[j];
			     	
			     	cout<<" -"<<znak[j]<<"-";
				}
		
		for(j=0;j<t; j++)
		{	
		
			if(symbol[i]==znak[j])
			{ 
				dol = sump[j];
				gora = sump[j+1];
					
				j = t;
				
			}
		}
		
		sump[0] = dol;
		sump[t] = gora;
		cout<<endl;
		for(j=1; j<t; j++)
		{
			podstawa = gora-dol;
			sump[j] = sump[j-1] + prawd[j-1]*podstawa;
			
		}
		
	}
0

Podaj kod który można wrzucić do debugera lub sam to zrób.

0

kod do kompilacji:

 	#include <cstdlib>
#include <iostream>
#include <string>
#include <fstream>
#include <iomanip>
#include <math.h>
#include <vector>
using namespace std;

int main()
{

	
	vector <float> prawd(1000);
	vector <float> sump(1000);
	float tab[1000];
	float tab1[1000];
	float dol ;
	float gora;
	float podstawa;
	float prawdo;
	int i;
	int t=4;
	
	float ilosc[1000];
	ilosc[0]=2;
	ilosc[1]=1;
	ilosc[2]=1;
	
	string symbol[100]={"baca"};
	string znak[100]={"abc"};

	for(i=0; i<t-1;i++)
	{
		
				
		tab1[i] = ilosc[i]/4;
		cout<<" "<<tab1[i]<<endl;
	}
	
	
	sump[0] = 0;
	for(i=0; i<t;i++)
	{
		
		
		tab[i+1] = tab[i] + tab1[i];
		
	}
	

	
	for(i=0; i<t;i++)
	{
		sump[i]=tab[i];
		prawd[i]=tab1[i];
		cout<<"  "<<tab[i]<<" ";
	}
	cout<<endl;
	/////// ZNALEZIENIE PRZEDZIALU  ////////	
	//cout<<ilosc_i<<endl;
	int j;
	for(i=0;i<4;i++)
	{	
		cout<<"przedzial  : ";
		
		for(j=0; j<=t-1; j++)
				{
			     	cout<<" "<<sump[j];
			     	
			     	cout<<" -"<<znak[j]<<"-";
				}
		
		for(j=0;j<t; j++)
		{	
		
			if(symbol[i]==znak[j])
			{ 
				dol = sump[j];
				gora = sump[j+1];
					
				j = t;
				
			}
		}
		
		sump[0] = dol;
		sump[t] = gora;
		cout<<endl;
		for(j=1; j<t; j++)
		{
			podstawa = gora-dol;
			sump[j] = sump[j-1] + prawd[j-1]*podstawa;
			
		}
		
	}
	system("pause");
	return 0;
}
0

Udało mi się zrobić to w ten sposób:

 	#include <cstdlib>
#include <iostream>
#include <string>
#include <fstream>
#include <iomanip>
#include <math.h>
#include <vector>
using namespace std;

int main()
{

	
	//vector <float> prawd(1000);
	//vector <float> sump(1000);
	float sump[1000];
	float prawd[1000];
	float dol ;
	float gora;
	float podstawa;
	float prawdo;
	int i;
	int t=4;
	
	float ilosc[1000];
	ilosc[0]=2;
	ilosc[1]=1;
	ilosc[2]=1;
	
	char symbol[100]={'b','a','c','a'};
	char znak[100]={'a','b','c'};

	for(i=0; i<t-1;i++)
	{
		
				
		prawd[i] = ilosc[i]/4;
		cout<<" "<<prawd[i]<<endl;
	}
	
	
	//sump[0] = 0;
	for(i=0; i<t;i++)
	{
		
		
		sump[i+1] = sump[i] + prawd[i];
		
	}
	

	

	cout<<endl;
	/////// ZNALEZIENIE PRZEDZIALU  ////////	
	//cout<<ilosc_i<<endl;
	int j;
	for(i=0;i<4;i++)
	{	
		cout<<"przedzial  : ";
		
		for(j=0; j<=t-1; j++)
				{
			     	cout<<" "<<sump[j];
			     	
			     	cout<<" -"<<znak[j]<<"-";
				}
		
		for(j=0;j<t; j++)
		{	
		
			if(symbol[i]==znak[j])
			{ 
				dol = sump[j];
				gora = sump[j+1];
					
				j = t;
				
			}
		}
		
		sump[0] = dol;
		sump[t] = gora;
		cout<<endl;
		for(j=1; j<t; j++)
		{
			podstawa = gora-dol;
			sump[j] = sump[j-1] + prawd[j-1]*podstawa;
			
		}
		
	}
		cout<<endl<<endl;
	cout<<sump[0]<<" oraz "<<sump[t]<<endl;
	system("pause");
	return 0;
}
0

tab[i+1] = tab[i] + tab1[i]; zaś w tab masz śmieci bo nie zainicjalizowałeś.
float tab[1000]={0};
lub
vector<float> tab(1000);

0

Dzięki wielkie ! Udało się napisać, wstawiam kod samej kompresji naiwnym algorytmem (do około 10 znaków) dla potomnych.

 #include <cstdlib>
#include <iostream>
#include <string>
#include <fstream>
#include <iomanip>
#include <math.h>
#include <vector>
using namespace std;
/*
//////////////////////////////////////////////////////////////////////////////////////////////////
				FUNKCJA ZLICZAJACA ILOSC WSZYSTKICH ZNAKOW

////////////////////////////////////////////////////////////////////////////////////////////////
*/

int lznakow(string nazwa_pliku_wejsciowego , ifstream &plik_odczyt, ofstream &plik_zapis) //definicja funkcji wczytujacej/tworzacej pliki zliczającej ilosc znakow w pliku
{
		string tekst ;
		
	

	plik_odczyt.open(nazwa_pliku_wejsciowego.c_str());

   
	if (!plik_odczyt.is_open())
	{
		cout << "Blad otwierania pliku odczytywanego w trybie tekstowym!" << endl;
		return -1;
	}

	string t; //zmienna potrzebna do zliczenia znakow w wilu wierszach 

	while(getline(plik_odczyt, tekst)) //zliczanie linii i laczenie tekstu
	{
		t=t+tekst;
	
	}
		
	int dlugosc = 0;
	
		
			for(int i =1;t.length()>=i;i++) //petla zliczajaca ilosc znakow
		{
		
			
			dlugosc++;
		}
		
		

	cout<<"\nilosc znakow w tekscie: "<<dlugosc<<endl;
	
	
	

	plik_zapis.open("tekst.ile");


	if (!plik_zapis.is_open())
	{
		cout << "Blad otwierania pliku do zapisu w trybie tekstowym!" << endl;
		return -1;
	}

			plik_zapis<<dlugosc<<" : tyle wynosi ilosc znakow w pliku "; //zapisanie do pliku ilosci znakow w tekscie

	while (true)
	{
		
		plik_odczyt >> tekst;
	
	
		if (!plik_odczyt.good()) break;
		
		plik_zapis << tekst << endl;
	
			
	}

	
	
		
	plik_odczyt.close();

	plik_zapis.close();
	
	return 0;
}
/*
///////////////////////////////////////////////////////////////////////////////////////////
				FUNKCJA ZLICZAJACA ILOSC POSZCZEGOLNYCH ZNAKOW

/////////////////////////////////////////////////////////////////////////////////////////

*/

int lznak(string nazwa_pliku_wejsciowego, ifstream &plik_odczyt, ofstream &plik_zapis)
{
	
	
		string tekst ;
		
	

	plik_odczyt.open(nazwa_pliku_wejsciowego.c_str());

   
	if (!plik_odczyt.is_open())
	{
		cout << "Blad otwierania pliku odczytywanego w trybie tekstowym!" << endl;
		return -1;
	}
	

	
        char zdanie[484000]; //tablica przechowująca wczytane zdanie
        int zlicz[127] = {}; //wyzerowania tablica przechowująca zliczenia liter
        int tmp = 0;
 
	while(!plik_odczyt.eof())
	{
		plik_odczyt >> zdanie[tmp++];
	}
	
    
        int i=0; //zmienna do poruszania po komórkach tablicy
 
        while(zdanie[i]) //lub zdanie[i]!=0
        {
                ++zlicz[zdanie[i]]; //zliczanie znaków
                ++i;
        }
 
       

 
 
 	plik_zapis.open("tekst.model");


	if (!plik_zapis.is_open())
	{
		cout << "Blad otwierania pliku do zapisu w trybie tekstowym!" << endl;
		return -1;
	}
		
		 for(int i=0;i<127;i++) //wypisanie wystąpień znakow ASCII 
		 {		 
                if(zlicz[i]) 
                {        
                        cout<<(char)i<<"  "<<zlicz[i]<<endl;
				
						plik_zapis<<(char)i<<"  "<<zlicz[i]<<endl; //zapisanie do pliku ilosci znakow w tekscie
				}
		}
	while (true)
	{
		
		plik_odczyt >> tekst;
	
	
		if (!plik_odczyt.good()) break;
		
		plik_zapis << tekst << endl;
	
			
	}

	
	
		
	plik_odczyt.close();

	plik_zapis.close();
	
	return 0;
 
 
}
/*
///////////////////////////////////////////////////////////////////////////////
					FUNKCJA SORTUJACA MALEJACO WYSTAPIENIA ZNAKOW

///////////////////////////////////////////////////////////////////////////////
*/

int sort(ifstream &plik_odczyt, ofstream &plik_zapis)
{
	
	
		string tekst ;
		
	

	plik_odczyt.open("tekst.model");

   
	if (!plik_odczyt.is_open())
	{
		cout << "Blad otwierania pliku odczytywanego w trybie tekstowym!" << endl;
		return -1;
	}
	
    string znak[127];
    long long int ilosc[90000];
  
  	
  	
  	
  	int t =0,j=0;
  	while(!plik_odczyt.eof())
	{
		plik_odczyt>>znak[j++]>>ilosc[t++];	
	}
	plik_odczyt.close();	
		
		string tmpc;
		int tmp = 0;
for(int p = 0;p<t;p++)	
{
	
	for(int i =0; i<t-2;i++)
		{
			if(ilosc[i]<=ilosc[i+1])
						
			{
				tmp = ilosc[i];
				ilosc[i] = ilosc[i+1];
				ilosc[i+1] = tmp;
				
				tmpc = znak[i];
				znak[i] = znak[i+1];
				znak[i+1] = tmpc;
				
			}
		}
}
	


	
		plik_zapis.open("tekst.modelsort");


	if (!plik_zapis.is_open())
	{
		cout << "Blad otwierania pliku do zapisu w trybie tekstowym!" << endl;
		return -1;
	}
		
		
		
		
		
		 for(int i=0;i<t-1;i++) //wypisanie wystąpień znakow ASCII 
		 {		 
		 	 plik_zapis<<znak[i]<<"  "<<ilosc[i]<<endl;
             cout<<znak[i]<<" "<<ilosc[i]<<endl; 
		 }
		 
	while (true)
	{
		
		plik_odczyt >> tekst;
	
	
		if (!plik_odczyt.good()) break;
		
		plik_zapis << tekst << endl;
	
			
	}


	
	plik_zapis.close();		
	return 0;
}

/*
////////////////////////////////////////////////////////////////////////////////////////
					KODOWANIE ARYTMETYCZNE	


////////////////////////////////////////////////////////////////////////////////////////
*/

int art(string nazwa_pliku_wejsciowego,string nazwa_modelsort,ifstream &plik_odczyt_i, ifstream &plik_odczyt, ofstream &plik_zapis)
{
	
	
		string tekst ;
		
	
/////// DO ODCZYTYWANIA KOLEJNO ZNAKOW  /////////


plik_odczyt.open(nazwa_pliku_wejsciowego.c_str());

   
	if (!plik_odczyt.is_open())
	{
		cout << "Blad otwierania pliku odczytywanego w trybie tekstowym!" << endl;
		return -1;
	}
	
    char symbol[10000];
   
  
  	
  	int g = 0;
  	while(!plik_odczyt.eof())
	{
		plik_odczyt>>symbol[g++];	
		
	}
	plik_odczyt.close();	


/////////////////////
	plik_odczyt.open(nazwa_modelsort.c_str());

   
	if (!plik_odczyt.is_open())
	{
		cout << "Blad otwierania pliku odczytywanego w trybie tekstowym!" << endl;
		return -1;
	}
	
    char znak[127];
    long long int ilosc[90000];
  
  	
  	int t =0,b=0;
  	while(!plik_odczyt.eof())
	{
		plik_odczyt>>znak[b++]>>ilosc[t++];	
		
	}
	plik_odczyt.close();	
	
	/////// WCZYTANIE DLUGOSCI Z PLIKU  //////////
	
	plik_odczyt_i.open("tekst.ile");

   
	if (!plik_odczyt_i.is_open())
	{
		cout << "Blad otwierania pliku odczytywanego w trybie tekstowym!" << endl;
		return -1;
	}
    
    double ilosc_i;  
        
		plik_odczyt_i>>ilosc_i;	
		
	
	plik_odczyt_i.close();	
	
	
	////// WYLICZENIE PRAWDOPODOBIENSTW  /////////
	
	
	
	vector <double> sump(90000);
	float prawd[10000];
	float dol ;
	float gora;
	float podstawa;
	float prawdo;
	int j;
	int i;
	
	for(i=0; i<t-1;i++)
	{
		
				
		prawd[i] = ilosc[i]/ilosc_i;
		cout<<znak[i]<<" "<<prawd[i]<<endl;
	}
	
	

	for(i=0; i<ilosc_i;i++)
	{
		
		
		sump[i+1] = sump[i] + prawd[i];
		
	}
	

	
	cout<<endl;
	/////// ZNALEZIENIE PRZEDZIALU  ////////	
	cout<<"przedzialy w kazdej iteracji"<<endl<<endl;

	for(i=0;i<ilosc_i;i++)
	{	
		cout<<"przedzial  : ";
		
		for(j=0; j<=t-1; j++)
				{
			     	cout<<" "<<sump[j];
			     	
			     	//cout<<" -"<<znak[j]<<"-";
				}
				cout<<endl;
		    // tu jest jeszcze dobrze
		for(j=0;j<ilosc_i; j++)
		{	
			
			if(symbol[i]==znak[j])
			{ 
				dol = sump[j];
				gora = sump[j+1];
					
				j = t;
				
			}
		} //tu jest dobrze sump[1]
		
		
		sump[0] = dol;
		sump[t] = gora;
		 //i tu dobrze
		cout<<endl;
		for(j=1; j<ilosc_i; j++)
		{
			podstawa = gora-dol;
			sump[j] = sump[j-1] + prawd[j-1]*podstawa;
			
		}
	}
		
	// ej no i tu dobrze
	cout<<endl<<"PRZEDZIAL DO ZAKODOWANIA "<<endl;
	cout<<sump[0]<<" oraz "<<sump[t];
	
	
	//////// KODOWANIE PRZEDZIALU ///////////////////
		
	
	float bin[20000];
		bin[0] = 0.5;
		for(i=1; i<20; i++){
			bin[i] = bin[i-1]/2;
		}
	
	
	
	
	
	
		plik_zapis.open("tekst.artm");


	if (!plik_zapis.is_open())
	{
		cout << "Blad otwierania pliku do zapisu w trybie tekstowym!" << endl;
		return -1;
	}
		
		
		
		
		
		 

	
	
	
	
	
	cout<<endl<<"KODOWANIE..."<<endl;
	
	float suma = 0;
	int wart = 1;
	i = 0;
	while(wart){
		if((bin[i]+suma)<gora){
			suma += bin[i];
			cout<<"1";
			plik_zapis<<"1";
		}
		else{
			cout<<"0";
			plik_zapis<<"0";
		}
		if(suma>dol)
			if(suma<gora)
				wart = 0;
		i++;
	}
	i--;
	
	while((bin[i]+suma)>gora){
		cout<<"0";
		plik_zapis<<"0";
		i++;
	}
	i++;



		 
	while (true)
	{
		
		plik_odczyt >> tekst;
	
	
		if (!plik_odczyt.good()) break;
		
		plik_zapis << tekst << endl;
	
			
	}
	plik_zapis.close();
	
 	return 0;


}
/*
////////////////////////////////////////////////////////////////////////////////////////
				GLOWNA FUNKCJA PROGRAMU
			
//////////////////////////////////////////////////////////////////////////////////////
*/

int main(int argc, char *argv[])
{
	string nazwa_pliku_wejsciowego ;
	string nazwa_modelsort;
	
	ifstream plik_odczyt;
	ofstream plik_zapis;
	ifstream plik_odczyt_i;
	int RetCode;
	

	
	if (argc<3)
	{
		cout << "Nie podano nazwy pliku jako parametru wejsciowego!" << endl;
		return -1;
	}
	

	
	nazwa_pliku_wejsciowego = argv[2];
	nazwa_modelsort = argv[1];
	
	cout << endl;
	
	cout << "Realizacja zadania ze zliczaniem wszystkich znakow" << endl << endl;
	
	RetCode = lznakow(nazwa_pliku_wejsciowego, plik_odczyt, plik_zapis);
	

	if (RetCode==-1) return -1;
	
	cout << endl;
	

	cout << endl;
			cout << "Realizacja zadania ze zwracaniem ilosci poszczegolnych znakow" << endl << endl;
	
	//wywołanie funkcji realizującej zadanie 2
	RetCode = lznak(nazwa_pliku_wejsciowego, plik_odczyt, plik_zapis);
	
		cout << endl;
	

	cout << endl;
			cout << "Posortowanie ilosci poszczegolnych znakow malejaco" << endl << endl;
	
	//wywołanie funkcji realizującej zadanie 2
	RetCode = sort(plik_odczyt, plik_zapis);


cout << endl;
			cout << "Kodowanie arytmetyczne z *.modelsort " << endl << endl;
	
	//wywołanie funkcji realizującej zadanie 3
	RetCode = art(nazwa_pliku_wejsciowego, nazwa_modelsort ,plik_odczyt_i ,plik_odczyt, plik_zapis);

	cout << endl;
		
	//sprawdzenie wyniku wykonania funkcji
	if (RetCode==-1)
		return -1;
	else
		return 0;
	
}
1

OMG !!! Bez butelki wódki nie da się na to patrzyć! Przerobie "po ludzku" pierwszą funkcje.

int lznakow(const char *nameIn,const char *nameOut) // nie przekazuj strumieni bo ich zrobisz lokalnie, nie przekazuj nazwy pliku jako string bo ograniczasz sobie możliwości.
  {
   ifstream fin(nameIn,ios::in|ios::binary);
   if(!fin) { cerr<<"Blad otwierania pliku odczytywanego!"<<endl; return -1; }
   fin.seekg(ios::end);
   size_t filesize=fin.tellg();
   cout<<"ilosc znakow w tekscie: "<<filesize<<endl;
   string content(filesize,0);
   fin.seekg(ios::beg);
   fin.read(&content[0],filesize);
   fin.close();
   ofstream fout(nameOut,ios::out|ios::binary);
   if(!fout) { cerr<<"Blad otwierania pliku  do zapisu!"<<endl; return -1; }
   fout<<filesize<<" : tyle wynosi ilosc znakow w pliku\r\n";
   fout.write(content,filesize);
   fout.close();
   return 0;
  }
0

Proszę o wyjaśnienie bo od jakiegoś czasu przeszukuje internet, czytam literaturę i za grom jedyny nie mogę pojąć jak działa kodowanie arytmetyczne. Chodzi mi tutaj o implementację, którą faktycznie można wykorzystać do skompresowania jakiejś wiadomości. Pytanie moje odnosi się do tego jak odbywa się zapis do pliku słowa kodowego składającego się z zer i jedynek, które otrzymaliśmy z końcowego przedziału jak RÓWNIEŻ z wcześniejszych przeskalowywań przedziałów. Już dla nieznacznej długości ciągu znaków wejściowych wykonywanych jest kilkanaście operacji przeskalowywania co powoduje, ze słowo kodowe rośnie w zastraszającym tempie. Zapis do pliku w formie tablicy char[] powoduje znaczy wzrost wielkości pliku wyjściowego - co zupełnie mija się z celem kompresji. Proszę o pomoc.

1

Zauważ że jeden bajt to 8 bitów (zer/jedynek)

0

no na kartce niby tak ale jak zapisuje to w tablicy char to każdy element waży 1 bajt

0
unsigned tabSize;
char *tab;
...
unsigned bitTabSize=(tabSize+7)>>3;
unsigned char *bitTab=new unsigned char[bitTabSize];
memset(bitTab,0,bitTabSize);
for(int i=0,k=0;i<tabSize;k=(++i)>>3) (bitTab[k]<<=1)|=(tab[i]=='1');
0

Twój kod zawiera chyba jakieś literówki, mógłbyś je poprawić bo nie bardzo czaję co jego ideę.

0

Zacznij od przeczytania jakiegoś kursu, inaczej zawsze będziesz chybiać.

0

czyli nie ma tam literówek ? :P
for(int i=0,k=0;i<tabSize;k=(++i)>>3) (bitTab[k]<<=1)|=(tabSize[i]==1);

tabSize jest tablicą ? ciężko to zrozumieć jeśli się nie wie co autor miał na myśli ;)

0

na razie mój program jest strasznie chaotyczny. Ciężko jednak pójść coś dalej jeśli nie wiem jak to działa. Googluję to już od 2 tygodni i nic. Wypluwam jedynki/zera do do tablicy char ja następnie wyrzucam do pliku (funkcja fwrite()). i widzę po rozmiarze pliku, że jeśli dodam jedną jedynkę to dodało jeden bajt, jeśli dwie - to 2 bajty.

0

prosta rzecz:

char tablica[10] = {'0', '1', '0', '1', '0', '0', '1', '1', '0', '1'};
fwrite(tablica, sizeof(tablica), 1 ,wy);

i plik ma 10 bajtów - każdy znak kodowany jest na 8 bitach i to w sumie rozumiem. Jak więc dodawać do rejestru zera/jedynki wykorzystując przy tym jak najmniej zasobów?

0

Dzięki, mam chyba to co chciałem. Załączam, może komuś się przyda(przykładowa tablica 16 elementowa, brakuje bibliotek).

int main(){

FILE *we, *wy;
const unsigned tabSize = 14;
char tab[tabSize] = {'0', '1', '0', '1', '0', '1', '0', '1', '1', '1', '0', '0', '0', '1'};

wy = fopen("out.txt", "wb");

unsigned bitTabSize = ceil(double(tabSize)/8);

cout << bitTabSize << endl;

unsigned char *bitTab = new unsigned char[bitTabSize];

memset(bitTab, 0, bitTabSize);

for(int i=0, k=0 ; i < tabSize ; k=(++i)>>3)
{
    (bitTab[k]<<=1)|=(tab[i]=='1');
}

cout << bitTab[0] <<" "<< bitTab[1];

return 0;

}

1 użytkowników online, w tym zalogowanych: 0, gości: 1