alch1337

aeufsgdfhiofkl

Mar 31st, 2015
228
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 4.81 KB | None | 0 0
  1. /**
  2. * TODO
  3. * stworzyc typ danych bitowy (bitset) (tablica zero jedynek), ale
  4. * tablicowy, czyli przechowujacy wiele wartosci i funkcje do oblsugi opisane
  5. * w pliku bits.h
  6. *
  7. * 1. zaimplementowac funkcje opisanych w pliku bits.h, gdzie jeden element
  8. * tablicy (jeden bajt) odpowiada, za jedna wartosc.
  9. *
  10. * 2. napisac funkcje wypisujace bitset zerojedynkowo (zeby sprawdzac czy bity
  11. * ustawiono poprawnie)
  12. *
  13. * 3. napisac test jednostkowy (gotowa funkcja assert z assert.h)
  14. * sprawdzajaca poprawnosc funkcji. Dla ustawionych kilu bitow sprawdzic czy
  15. * funkcja zwraca niezero dla tych bitow i zero dla pozostalych
  16. *
  17. * 4. Dopisac nowy typ i funkcje, ktore bedą operowac juz na bitach (jeden
  18. * bajt=8 wartosci) (nowe nazwy funkcji, typu)
  19. *
  20. * 5. Przepisac funkcje, zeby byly makrami.
  21. *
  22. * 6. Rozszerzyc typ oraz funkcje z zadania 4. tak by pamiec byla alokowana
  23. * dynamicznie (tablica intow); dopisanie funkcji:
  24. * void * bit_create(int n);
  25. * ktora bedzie korzystala z wyimagonego, tylko jej wiadomego typu (tez jakas
  26. * niejawna struktura rzutowana na void*). Dla otoczenia bedzie "(void*)"
  27. * ktora bedzie zawierala limit wartosci a funkcje beda sprawdzaly czy limit
  28. * nie zostal przekroczony.
  29. *
  30. *
  31. * konieczne operatory i funkcje do wykonania zadania:
  32. * & | ~: operatory bitowe (materialy do zajec #3)
  33. * << >>: przesuniecia bitowe (materialy do zajec #3)
  34. * assert: sprawdza czy argument nie jest zerem. Jesli jest konczy program
  35. * podajac linie w ktorej program sie skonczyl
  36. * (TYP): rzutowanie, zmiana typu (potrzebne do zad. 6)
  37. * & *: uzyskanie adresu do zmiennej, zmiennej z adresu
  38. */
  39.  
  40. #include <stdio.h>
  41. #include "bits.h"
  42.  
  43. int main(int argc, char **argv)
  44. {
  45. struct bit_set val;
  46. bits_reset(&val);
  47. bits_set(&val, 15);
  48. printf("%d\n", bits_count(&val));
  49. printf("%d\n", bits_isset(&val, 14));
  50. printf("%d\n", bits_isset(&val, 15));
  51. printf("%d\n", bits_isset(&val, 16));
  52. printf("%d\n", bits_all(&val));
  53. printf("%d\n\n", bits_any(&val));
  54.  
  55. bits_unset(&val, 15);
  56. printf("%d\n", bits_count(&val));
  57. printf("%d\n", bits_isset(&val, 14));
  58. printf("%d\n", bits_isset(&val, 15));
  59. printf("%d\n", bits_isset(&val, 16));
  60. printf("%d\n", bits_all(&val));
  61. printf("%d\n\n", bits_any(&val));
  62.  
  63. int i;
  64. for (i = 0; i < 80; ++i)
  65. bits_set(&val, i);
  66. printf("%d\n", bits_count(&val));
  67. printf("%d\n", bits_all(&val));
  68. printf("%d\n\n", bits_any(&val));
  69.  
  70. bits_unset(&val, 15);
  71. printf("%d\n", bits_count(&val));
  72. printf("%d\n", bits_all(&val));
  73. printf("%d\n\n", bits_any(&val));
  74.  
  75. bits_reset(&val);
  76. printf("%d\n", bits_count(&val));
  77. printf("%d\n", bits_all(&val));
  78. printf("%d\n\n", bits_any(&val));
  79.  
  80. return 0;
  81. }
  82.  
  83.  
  84.  
  85. asdadfasdgfasdgasdfghsdf
  86.  
  87. #pragma once
  88.  
  89. #define MAX 255
  90.  
  91. struct bit_set {
  92. char tab[10];
  93. };
  94.  
  95. struct bit_set_2 {
  96. int *tab;
  97. int len;
  98. int max = MAX;
  99. };
  100.  
  101. /**
  102. * ustawienie n-tego bita na jeden
  103. */
  104. void bits_set(struct bit_set * val, int n);
  105.  
  106. /**
  107. * ustawienie n-tego bita na zero
  108. */
  109. void bits_unset(struct bit_set * val, int n);
  110.  
  111. /**
  112. * sprawdzenie czy n-ty bit jest jedynka
  113. */
  114. int bits_isset(struct bit_set * val, int n);
  115.  
  116.  
  117. /**
  118. * sprawdzenie ile bitow jest jedynka
  119. */
  120. int bits_count(struct bit_set * val);
  121.  
  122. /**
  123. * sprawdzenie czy wszystkie bity sa jedynka
  124. */
  125. int bits_all(struct bit_set * val);
  126.  
  127. /**
  128. * sprawdzenie czy jakikolwiek bit jest jedynka
  129. */
  130. int bits_any(struct bit_set * val);
  131.  
  132. /**
  133. * ustawienie wszystkich bitow na 0
  134. */
  135. void bits_reset(struct bit_set * val);
  136.  
  137. void *bit_create(int n);
  138.  
  139. frasdfasdgfasdgasfgasd
  140.  
  141. #include "bits.h"
  142.  
  143. struct bit_set_2 bits;
  144. /**
  145. * ustawienie n-tego bita na jeden
  146. */
  147. void bits_set(struct bit_set * val, int n) {
  148. val->tab[n/8] = val->tab[n/8] | (1 << (n%8));
  149. }
  150.  
  151. /**
  152. * ustawienie n-tego bita na zero
  153. */
  154. void bits_unset(struct bit_set * val, int n) {
  155. val->tab[n/8] = val->tab[n/8] & ((~0) ^ (1 << (n%8)));
  156. }
  157.  
  158. /**
  159. * sprawdzenie czy n-ty bit jest jedynka
  160. */
  161. int bits_isset(struct bit_set * val, int n) {
  162. return (val->tab[n/8] & (1 << (n%8))) ? 1 : 0;
  163. }
  164.  
  165. /**
  166. * sprawdzenie ile bitow jest jedynka
  167. */
  168. int bits_count(struct bit_set * val) {
  169. int i, count = 0;
  170. for (i = 0; i < 8*10; ++i)
  171. if (bits_isset(val, i))
  172. ++count;
  173. return count;
  174. }
  175.  
  176. /**
  177. * sprawdzenie czy wszystkie bity sa jedynka
  178. */
  179. int bits_all(struct bit_set * val) {
  180. int i;
  181. for (i = 0; i < 10; ++i)
  182. if ((val->tab[i] ^ (~0)))
  183. return 0;
  184. return 1;
  185. }
  186.  
  187. /**
  188. * sprawdzenie czy jakikolwiek bit jest jedynka
  189. */
  190. int bits_any(struct bit_set * val) {
  191. int i;
  192. for (i = 0; i < 10; ++i)
  193. if ((val->tab[i] & (~0)))
  194. return 1;
  195. return 0;
  196. }
  197.  
  198. /**
  199. * ustawienie wszystkich bitow na 0
  200. */
  201. void bits_reset(struct bit_set * val) {
  202. int i;
  203. for (i = 0; i < 10; ++i)
  204. val->tab[i] &= 0;
  205. }
  206.  
  207. void *bit_create(int n) {
  208.  
  209. }
Advertisement
Add Comment
Please, Sign In to add comment