Puchacz1

pytanie nr. 6 To pytanie bardziej w kwestii algorytmiki niż samego C++. Potrzebuję zrobić menu w którym będę mógł cofać się wstecz. Chyba zrobiłbym to nieskończoną pętlą while() i ewentualnie warunkami.Ogólnie wyglądałoby to tak: while(true){ switch zmienna { case:0 while(true) { if przerwij == 1 break; else while() <--kolejny poziom menu } case:1 while(true) { if przerwij == 1 break; else while() <--kolejny poziom menu } }}oczywiście odpowiednio bym sobie tym sterował tak abym uzyskał przejście z menu do podmenu jednak zastanawiam się czy nie ma innego sposobu. Poza goto bo to zapewne jest złą praktyką :)

nie jestem aż tak biegły żeby ogarnąć szablony (jeszcze) niemniej jednak dzięki i na pewno się przyda!. Dopiero co wkroczyłem w świat programowania obiektowego a problem z pytania nr. 2 rozwiązałem najprościej jak się tylko dało. Tworzę o 1 większą tablicę i wpisuję w nią wartość charakterystyczną którą mam pewność, że nie wystąpi. Napisałem funkcję rozmiar przelatującą po tablicy aż do momentu znalezienia tej liczby i zwracającej rozmiar. Rozwiązanie ma wiele wad ale nic bardziej zaawansowanego nie było mi po prostu potrzebne. Kolejne pytanie: 4. Jak stworzyć własny operator i nie chodzi tutaj o przeładowanie operatorów np. += tylko o tworzenie własnego operatora działającego na danej klasie (np. operator ^T) w tym przypadku dokonujący transpozycji macierzy. Nie mogłem tego nigdzie znaleźć a i książki nie wiele mi powiedziały. 5. Jak pisać funkcję tak aby środowisko zamiast wyświetlania podpowiedzi typu (int x, bool y) wyświetlało (podpowiedź 1, podpowiedź2). Wydaje mi się, że trzeba jakoś inaczej zapisać prototyp funkcji ale nie mogłem tego znaleźć.

mam taki oto prosty program który pod środowiskiem kompiluje się poprawnie (ale przy uruchamianiu wyrzuca: terminate called after throwing an instance of 'std::logic_error' what(): basic_string::_S_construct NULL not valid ) natomiast przy kompilacji (g++ -Wall -pedantic -o nazwa nazwa.cpp) wyrzuca jakieś niezrozumiałe instrukcje których tu nie będę przytaczał bo jest tego bardzo dużo.Powiedzcie co robię źle. #include <iostream>#include <fstream>#include <string>using namespace std;struct Osoba{ string nazwisko; string imie; string wiek;};bool wczytaj(string &nazwa, Osoba *&dane, int &ile){ ofstream plik; plik.open(nazwa.c_str(), ios::in | ios::out); plik << ile; if(ile!=0) { dane = new Osoba [ile]; for(int i=0; i<ile; ++i) { if(plik.good()) { plik << dane[i].imie << dane[i].nazwisko << dane[i].wiek; } } return 1; } else { cerr << "Pusty plik bądź brak informacji o rozmiarze"; return 0; }}void wypisz(ostream &plik, Osoba &dane){ plik << dane.imie << dane.nazwisko << dane.wiek;}int main(int argc, char *argv[]){ string pl_wej(argv[1]); string pl_wyj(argv[2]); int ile; // Osoba *dane; if(!wczytaj(pl_wej, dane, ile)) { cerr << "[gluteus maximus] zbita"; } wypisz(cout, dane[2]); return 0;}

Pozwólcie, że będę tu pytał o nurtujące mnie pytania związane z językiem programowania C++. Pytanie nr. 1: Dlaczego tworząc dynamiczną tablicę w funkcji zwracającej tą tablicę (przez wskaźnik) nie muszę zwalniać zaalokowanej przez nią pamięć przy kończeniu pracy programu. [przykładowy kod] int *tablica(n){ int *asd = new int [n]; return asd;}int main(){ int *zmienna = tablica(10); return 0;}Pytanie nr. 2: Dlaczego nie mogę określić rozmiaru tablicy zadeklarowanej w funkcji zwracającej wskaźnik na pierwszy element tablicy. Czy nie jest to przypadkiem dlatego, że zwracając wskaźnik na pierwszy element gubię informację gdzie kończy się tablica? (mogę wędrować po "nieswojej" części pamięci?). Czy rozwiązaniem nie byłoby zwracaniem tablicy wskaźników na pierwszy i ostatni element? Oczywiście mogę to rozwiązać tworząc tablicę zawsze o 1 element większą i zapisując w niej jakąś umowną wartość a następnie napisać funkcję sprawdzająca rozmiar jednak chodzi o sam fakt "dlaczego tak się dzieje". int *tablica(n){ int *asd = new int [n]; return asd;}int main(){ int *zmienna = tablica(10); //tu chcę zbadać rozmiar tablicy (np. sizeof) return 0;}Pytanie nr.3 Czy mając tablicę wskaźników mogę wpisywać do takiej tablicy wskaźniki na różne typy danych? (string, int, double) i to chwilowo wszystko :)

Chcę przemnożyć macierz n x n przez wektor (kolumnowy) o rozmiarze n jednak coś mi nie wychodzi float *MacierzWektor(float **Mac, float *X, int n){ for(unsigned short int i=0; i<n; ++i) for(unsigned short int j=0; j<n; ++j) X[i]+=Mac[i][j]*X[j]; return X;}prosiłbym o wskazanie błędu.

dzięki ;)

problem w tym, że kompilatorem jest GCC w wersji 4.5.2. Jakby tego było mało to kilka dni wcześniej pisałem program wykonujący podobne obliczenia i on działał... Dlaczego zmienna temp wyrzuca -inf bądź -nan bądź 0. Nie mogę tego zrozumieć. Próbowałem to kompilować na: Code::Blocks pod: Windows7, Ubuntu 11.04, Ideone.com - wszędzie zwraca takie błędy więc to nie może być kwestia kompilatora.

mam taki prościutki kod.Funkcja f zwraca poprawne wyniki natomiast działania w main to jakieś wierutne bzdury :). Nie jestem w stanie podzielić nic poprawnie bo zwraca -inf -nan albo po prostu 0.000000 w zmiennej a. Pętla specjalnie wykonuję się tylko jeden raz. Dla diagnostyki wyniku. Pomóżcie :) float f(float (&a)[9], float x){ float y=0; y=a[2]*pow(x,a[3])+a[4]*pow(x,a[5])+a[6]*pow(x,a[7]); return y;}int main(){ float tab[9]={-1,1,1,3,-1,1,-1,0,0.001}; float a=tab[0]; float b=tab[1]; float temp[2]={0,0}; float EPS0=tab[8]; float x; float y; float z; float c; unsigned short int i=0; while(i<1) { x=f(tab,a); y=f(tab,b); z=b-a; c=x+y; temp[0]=a+(z/c)*x; cout.precision(5); cout << fixed << x << " " << y << " " << z << " " << "a: " << a; if((i!=0)&&(a-a<EPS0)) break; i++; } return 0;}

jak w temacie, wprowadzam dane raz w taki sposób: long double *wprowadz(){ long double wprowadzone[9] = {0}; while(wprowadzone[0]<2 || wprowadzone[0]>7) { cout << "Podaj liczbę węzłów (min. 2, max.7)" << endl; cin >> wprowadzone[0]; } // cout << "podaj współczynnik a: " << endl; cin >> wprowadzone[1]; cout << "podaj potege x: " << endl; cin >> wprowadzone[2]; // cout << "podaj współczynnik a: " << endl; cin >> wprowadzone[3]; cout << "podaj potege x: " << endl; cin >> wprowadzone[4]; // cout << "podaj współczynnik a: " << endl; cin >> wprowadzone[5]; cout << "podaj potege x: " << endl; cin >> wprowadzone[6]; // cout << "podaj poczatek przedzialu: " << endl; cin >> wprowadzone[7]; cout << "podaj koniec przedzialu" << endl; cin >> wprowadzone[8]; return wprowadzone;}2 sposób sprawdza poprawność wyników: long double dane[9] = {7,15,4,32,15,-1,1,2,5};i ten drugi sposób działa, a ten pierwszy daje wyniki z kosmosu... tak jest to wywoływane: int main(){ //long double *dane = wprowadz(); long double dane[9] = {7,15,4,32,15,-1,1,2,5}; int n = dane[0]; int a = dane[7]; int b = dane[8]; long double *x = zbiornik(n, a, b); long double wynik = (czebyszew(x, a, b, n, dane)*(b-a))/n; printf("Twoim wynikiem jest: %1.10Lf", wynik); return 0;}dlaczego wprowadzając dane na te 2 sposoby otrzymuje całkiem różne wyniki? sorki za trucie d*py

Nie, nie Gdańsk ;). Oczywiście printf pomogło. Zauważyłem jednak, że sama funkcja chyba liczy coś nie tak. Czasem daje dziwne wyniki i nie wiem czym to jest spowodowane. #include <iostream>#include <cmath>#include <cstdio>using namespace std;long double *wprowadz(){ long double wprowadzone[9] = {0,0,0,0,0,0,0,0,0}; cout << "Podaj liczbę węzłów (max.7)" << endl; cin >> wprowadzone[0]; // cout << "podaj współczynnik a: " << endl; cin >> wprowadzone[1]; cout << "podaj potege x: " << endl; cin >> wprowadzone[2]; // cout << "podaj współczynnik a: " << endl; cin >> wprowadzone[3]; cout << "podaj potege x: " << endl; cin >> wprowadzone[4]; // cout << "podaj współczynnik a: " << endl; cin >> wprowadzone[5]; cout << "podaj potege x: " << endl; cin >> wprowadzone[6]; // cout << "podaj poczatek przedzialu: " << endl; cin >> wprowadzone[7]; cout << "podaj koniec przedzialu" << endl; cin >> wprowadzone[8]; return wprowadzone;}long double *ti(int n){ //pierwszy element tablicy jest jej rozmiarem. //drugi element tablicy jest rozmiarem tworzonej tablicy x'ów if(n==2) { long double *t = new long double [3]; t[0] = 3; t[1] = 2; t[2] = 0.577350; return t; } else if(n==3) { long double *t = new long double [5]; t[0] = 5; t[1] = 6; t[2] = 0.707107; t[3] = 0.000000; t[4] = 0.707107; return t; } else if(n==4) { long double *t = new long double [6]; t[0] = 6; t[1] = 8; t[2] = 0.794654; t[3] = 0.187592; t[4] = 0.187592; t[5] = 0.794654; return t; } else if(n==7) { long double *t = new long double [6]; t[0] = 6; t[1] = 7; t[2] = 0.883862; t[3] = 0.529657; t[4] = 0.323912; t[5] = 0; } else { return 0; }}long double *zbiornik(int n, int a, int b){ long double *t = ti(n); int rozmiar = t[1]; // 2 element tablicy, poznaję rozmiar tablicy! cout << "t[1]: " << rozmiar << endl; int z = 2; long double *x = new long double [rozmiar]; for(int i=0; i<rozmiar; i+=2) { x[i+1] = (0.5)*(b + a) + ((0.5)*(b - a) * t[z]); x[i] = (0.5)*(b + a) + ((0.5)*(b - a) * (t[z] * (-1))); z++; cout << x[i] << " :x: " << x[i+1] << endl; } return x;}long double czebyszew(long double *wezly, int a, int b, int n, long double *xxx){ int rozmiar = 2; //musi być dynamicznie. Nie wiem jak sprawdzić rozmiar tablicy wezly[]. Jakaś sztuczka z sizeof() pewnie. long double suma = 0; for(int i=0; i<rozmiar; ++i) { suma = suma + (xxx[1]*pow(wezly[i],xxx[2])+xxx[3]*pow(wezly[i],xxx[4])+xxx[5]*pow(wezly[i],xxx[6])); //cout << suma << " = " << xxx[1] << " * " << pow(wezly[i],xxx[2]) << "+" << xxx[3] << " * " << pow(wezly[i],xxx[4]) << "+" << xxx[5] << " * " << pow(wezly[i],xxx[6]) << endl; } return suma;}void wypisz(long double *co, int n){ for(int i=0; i<n; ++i) //funkcja na razie nie potrzebna. { cout << co[i] << endl; }}int main(){ //long double *dane = wprowadz(); //funkcja działa ale dla sprawdzenia kodu stosuje tablice [opis poniżej] long double dane[9] = {2,1,5,2,2,1,0,1,4}; //pierwsze od lewej "2" to nasze n. wyrażenie jest w postaci z*x^c + z2*x^c + z*x^c. Ostatnie dwie cyfry to przedział (od 1-4, można zmienić). Całość w ogóle można zmienić, pamiętając jednak, że zaimplementowane jest jedynie n=2,3,4,7. int n = dane[0]; int a = dane[7]; int b = dane[8]; long double *x = zbiornik(n, a, b); long double wynik = (czebyszew(x, a, b, n, dane)*(b-a))/n; // tu kończymy prace mnożąc wynik przez (b-a)/n printf("%1.10Lf", wynik); return 0;} może Wy mi wskażecie błąd.

napisałem takie malutkie narzędzie do liczenia przybliżonego pola pod całką met. Czebyszewa jednak zastanawia mnie skąd biorą się tak duże zaokrąglenia w obliczeniach między mną a np. kalkulatorem online. Na przykład dla n=2 i przykładu x^2+2x+1 mój kalkulator wyświetla 39.0 a kalkulator online 38.99250. Oczywiście ja stosuję double więc teoretycznie powinienem otrzymać dość dokładny wynik. Liczyłem kalkulatorem i to mój program tak dziwacznie zaokrągla. Ja tego nie chcę wobec czego chciałbym się dowiedzieć jak to zmienić :) double czebyszew(double *wezly, int a, int b, int n, double *xxx){ int rozmiar = 4; //musi być dynamicznie. double suma = 0; for(int i=0; i<rozmiar; ++i) { suma = suma + (xxx[1]*pow(wezly[i],xxx[2])+xxx[3]*pow(wezly[i],xxx[4])+xxx[5]*pow(wezly[i],xxx[6])); //cout << suma << " = " << xxx[1] << " * " << pow(wezly[i],xxx[2]) << "+" << xxx[3] << " * " << pow(wezly[i],xxx[4]) << "+" << xxx[5] << " * " << pow(wezly[i],xxx[6]) << endl; } return suma;}problemy zaczynają się w tej funkcji. O ile tablica wezly[] jest ok i wydawać by się mogło, że zwróci dokładny wynik to przy kolejnych obrotach pętli wynik jest po prostu zaokrąglany. Niby wynik nie jest jakiś z kosmosu różny ale jednak. Po zwrócenia sumy robię jeszcze tak: double calka = ((b-a)/n) * czebyszew(parametry); może coś doradzicie.

dobra, już wiem co było źle. Jednak nadal pozostają problemem te liczby rzeczywiste z przedziału które nie wiem jak uzyskać. mam coś takiego: tablica = rand() * 100.00000 / RAND_MAX;

dobra, a jak z tego wyświetlić liczby losowe rzeczywiste. Niby google wie, ale jak to wklepuje to wypluwa tylko kilka liczb rzeczywistych, reszta to 0...

chciałem otrzymać liczby losowe... zawarłem więc #include <ctime> i #include <cstdlib> float *wypelnij(float *tablica, unsigned int rozmiar, int gora, int dol){ srand(time(NULL)); for(unsigned int i=0; i<rozmiar; ++i ) { tablica[i] = rand()%(gora-dol)+dol; } return tablica;} jednak to nie działa... otrzymuje same 1. pyt. 2 jak w argumentach funkcji main przekazać rozmiar tabeli "rozmiar"?. Przecie *argv[] jest tablicą charów int main (int argc, char *argv[]){ int rozmiar = ?}

nie za bardzo rozumiem o czym piszesz ale domyślam się, że chodzi o sztywne wbijanie współczynników itd... tak właśnie robię :) ps. napisałem funkcję licząca całkę metodą trapezów jednak nie jestem pewien prawidłowości jej działania. Mianowicie mam wrażenie czasem daje mało dokładne wyniki mimo dość dużej liczby kroków (10000) double *calkuj(int liczbaKrokow, float start, int stop, float a, float pot, float b, float pot2, float c, float pot3, float d, float pot4, float C ){ float krok = (sqrt(pow(stop-start,2)))/liczbaKrokow; //wartosc o jaka bedziemy przeskakiwali (np. 0,25) cout << "krok co:" << krok << endl; double *wynik = new double [liczbaKrokow]; //tworzymy dynamiczna tablice z liczba krokow. double y[2] = {0.00000000}; for(int i=0; i<liczbaKrokow; ++i) { if(i==0) { y[1] = a*pow(start,pot) + b*pow(start,pot2) + c*pow(start,pot3) + d*pow(start,pot4) + C; y[2] = a*pow(start+krok,pot) + b*pow(start+krok,pot2) + c*pow(start+krok,pot3) + d*pow(start+krok,pot4) + C; wynik[i] = ((y[1]+y[2])/2)* krok; if(wynik[i]<0) { wynik[i] *= -1; } } else if(i!=0) { y[1] = y[2]; y[2] = a*pow(start+krok,pot) + b*pow(start+krok,pot2) + c*pow(start+krok,pot3) + d*pow(start+krok,pot4) + C; wynik[i] = ((y[1]+y[2])/2)*krok; if(wynik[i]<0) { wynik[i] *= -1; } } start+=krok; } return wynik;} zastanawiam się czy na pewno jest to dobrze napisane.

witam, potrzebuję abym mógł wpisać wyrażenie np. 2x^2+2*x+3 i je obliczyć. Na jednym forum polecono mi skorzystać z ONP jednak to nieco zbyt złożone zadanie (narazie). Potrzebuję czegoś prostszego (obsługa tylko podst. wyrażeń) i tu pytanie. Czy jest to w ogóle wykonalne. O ile lecąc pętlą po stringu jestem w stanie odczytać liczby i je zapisać o tyle nie do końca wiem jak podmieniać znak (np. + na -). W ogóle jakoś nie mogę sobie wyobrazić takiego "dynamicznego" składania wyrażenia. W związku z tym proszę o pomoc, może jakąś podpowiedź. Takie coś mi wpada do głowy: mógłbym "na sztywno" wykrywać liczbę x w ciągu i mieć już gdzieś przygotowane wyrażenia dla odpowiedniej liczby zmiennych x. Jednak jak podmieniać w takim wyrażenia + na - lub / na jakakolwiek inna kombinacje.

Działa, dzięki. Z tym rozmiarem to było tak, że trochę zmieniałem koncepcję w trakcie pisania i tak zostało... :). Ale już poprawiłem.

a więc mam taką funkcję i potrzebuję utworzoną w niej tablice 2 wymiarową zwrócić (zwrócić adres na jej pierwszy element??). I robię to chyba dobrze ale nie potrafię tego później wywołać w funkcji wypisz3d() int *wyniki(int rozmiar, int tab1, int tab2, int tab3){ int ** tab = new int *[rozmiar]; for(int i=0; i<rozmiar; ++i) { tab[i] = new int[rozmiar/2]; } for(int i=0; i<rozmiar; ++i) { for(int j=0; j<3; ++j) { if(j==0) { tab[i][j] = tab1; } else if(j==1) { tab[i][j] = tab2; } else { tab[i][j] = tab3; } } } return tab[0];}void wypisz3d(int **tab, int rozmiar){ for(int i=0;i<rozmiar;++i) { for(int j=0;j<3;++j) { cout << tab[i][j]; } cout << "" << endl; }}tutaj tak próbuję to wywołać jednak mi nie wychodzi: int main(){ int *tab3d = wyniki(6, 1, 2, 3); wypisz3d(tab3d[0], 6); return true;}kompilator wypluwa : invalid conversion from `int` to `int**` Powiedzcie jak odwołać się prawidłowo do takiej tablicy.

dobra, wiem. Dzięki temu, że mamy tam powietrze ( a nie jak do tej pory myślałem) szybko wirujące talerze tworzą taką poduszkę która uniemożliwia stykanie się powierzchni ślizgaczy o powierzchnię talerzy.

witam, szukałem sporo w google ale nie mogę tego znaleźć. Jak rozwiązany jest problem cyrkulacji powietrza w dyskach twardych. Wiem, że same talerze pracują w próżni więc problem zapewne dotyczy pozostałych części dysku(z drugiej strony dyski pracujące z tak dużą prędkością muszą się nagrzewać). Wydaje mi się, że sama cyrkulacja powietrza w dysku twardym może być znikoma a rolę odbiorników ciepła przejmują tutaj połączone z obudową części które to właściwie odprowadzają ciepło na zewnątrz. Czy może cyrkulacja powietrza odgrywa tutaj jakąś inną rolę?. Mogą być linki (także po ang.)

piszę program do kodowania liczb w fp2. Mój problem polega na tym, że gdzieś tak konkretnie spartoliłem, że dalsze bity mantysy przypisuje błędnie. Pokazuje mi jakoś losowo 0-1 tymaczasem nie powinno. Powinno przypisać odpowiednie bity z tablicy Tab #include <iostream>#include <cmath>#include <algorithm>using namespace std;//rozmiar tablicy po konwersjiint rozmiar_tab_calk = 0;int *wsk_rozm_tab_calk = &rozmiar_tab_calk; //int rozmiar_tab_rzecz=0;int *wsk_rozm_tab_rzecz = &rozmiar_tab_rzecz;int mantysa=0;int *wsk_mantysa = &mantysa;void licz_rozmiar_tab_calk (int a){ cout<< "Podaj liczbę bitów mantysy: "; cin >> mantysa; while(a>0) { *wsk_rozm_tab_calk +=1; a /=2; }}short int *Tab = new short int[*wsk_rozm_tab_calk + *wsk_mantysa]; //dynamiczne stworzenie tablicy :)int dec_to_bin(long int a, double b, bool wypisz ){ //konwertujemy int i=0; while (a > 0) { if(a % 2 != 0) { Tab[i] = 1; } else { Tab[i] = 0; } // tablica testowa, jeśli true to wypisuje. if(wypisz == true) { cout << "Tab[" << i << "]: " << Tab[i] << endl; } a /= 2; i++; } return 0;}int pierwsza_jedynka = 997;int *wsk_pierwsza_jedynka = &pierwsza_jedynka;int odl_przec_od_jed = 0;int *wsk_odl_przec_od_jed = &odl_przec_od_jed;int obroc_tablice (bool inicjuj, bool wypisz){ int i=0; int pomocnicza; int rozm_tab = *wsk_rozm_tab_calk; while(i<*wsk_rozm_tab_calk) { if(i<ceil(*wsk_rozm_tab_calk/2)) { pomocnicza = Tab[i]; Tab[i] = Tab[rozm_tab - 1]; Tab[rozm_tab - 1] = pomocnicza; if(*wsk_pierwsza_jedynka == 997 && Tab[i] == 1) { *wsk_pierwsza_jedynka = i; //potrzebna do sprawdzenia na której pozycji występuje pierwsza jedynka w wyrażeniu. } if(wypisz == true) { cout << "Tab[" << i << "]: " << Tab[i] << " -> Tab[" << rozm_tab - 1 << "]: " << Tab[rozm_tab - 1] << endl; } rozm_tab--; } i++; } Tab[*wsk_rozm_tab_calk] = 999; //tworze przecinek xD *wsk_odl_przec_od_jed = *wsk_rozm_tab_calk; return true;}void dec_to_bin2(double a, int b, bool wypisz){ int i=0; while(i<b) { a*=2; if(a>0 && a<1) { Tab[*wsk_rozm_tab_calk+1]=0; } else if(a>1) { Tab[*wsk_rozm_tab_calk+1]=1; a = a - floor(a); } else if(a==1) { Tab[*wsk_rozm_tab_calk+1]=1; a=a-floor(a); } else { Tab[*wsk_rozm_tab_calk+1]=0; } *wsk_rozm_tab_calk +=1; i++; }}//ilosc bitow cechy.int rozmiar_cechy = 1;int *wsk_rozmiar_cechy = &rozmiar_cechy;void policz_rozmiar_cechy (int a, bool wypisz){ while(a > 0) { a /=2; *wsk_rozmiar_cechy +=1; } if(wypisz == true) { cout<<"*wsk_rozmiar_cechy: " << *wsk_rozmiar_cechy << endl; }}short int *fp2 = new short int[*wsk_rozmiar_cechy+*wsk_mantysa+2]; //tworzymy prawidłową tablicę z naszym fp2int kodowanie_cechy(bool wypisz, int znak){ *wsk_odl_przec_od_jed -=1; //odejmuje jeden aby zachować prawidłową odległość od pierwszej jedynki. if(wypisz == true) { cout << *wsk_odl_przec_od_jed <<endl; } int i=2; fp2[0]=znak; fp2[1]=0; while(*wsk_odl_przec_od_jed >0) { if(*wsk_odl_przec_od_jed % 2 != 0) { fp2[i] = 1; } else { fp2[i] = 0; } *wsk_odl_przec_od_jed /=2; i++; } return i;}int kodowanie_mantysy(int j, bool wypisz){ j+=1; int z=1; cout << *wsk_rozmiar_cechy+*wsk_mantysa+2 << endl; while(j<*wsk_rozmiar_cechy+*wsk_mantysa+2) { if(wypisz == true) { cout << "fp2[" << j << "]: " << fp2[j] << " = Tab[" << z << "]: " << Tab[z] << endl; } if(z != *wsk_rozmiar_cechy) { fp2[j] = Tab[z]; j++; } z++; }}void skasuj_tablice (){ delete [] Tab;}void wypisz_fp2(){ for(int i=0;i<*wsk_rozmiar_cechy+*wsk_mantysa+2;i++) { cout << "FP2[" << i << "]: " << fp2[i] << endl; }}void wypisz_tablice(int l){ for(int i=0;i<*wsk_rozm_tab_calk+l;i++) { cout << "Tab[" << i << "]: " << Tab[i] << endl; }}void ilosc_elem(){ int ilosc_elem_tab = sizeof(Tab) / sizeof(int); cout << ilosc_elem_tab;}//------------------------------------------------------------////-------------------------i++--------------------------------////------------------------------------------------------------//int main (){ cout << "Podaj liczbę: "; double liczba; cin >> liczba; //sprawdzanie czy liczba jest ujemna bool znak = 0; bool *wsk_znak = &znak; if(liczba < 0) { liczba = liczba * (-1); *wsk_znak = 1; } // konwersja liczby zmienno przecinkowej na całkowitą. long int licz_calk = liczba; double licz_rzecz = liczba - licz_calk; licz_rozmiar_tab_calk(licz_calk); // liczy rozmiar tablicy dec_to_bin(licz_calk, licz_rzecz, false); // wypełnia tablicę 0-1; obroc_tablice(true,false); //obraca tablicę 0-1 dec_to_bin2(licz_rzecz,*wsk_mantysa, false); wypisz_tablice(1); cout << "" << endl; policz_rozmiar_cechy(*wsk_odl_przec_od_jed-1, true); int ost_elem = kodowanie_cechy(true, znak); fp2[ost_elem] = 999; // mój przecinek. Pozwala mi separować ceche od mantysy kodowanie_mantysy(ost_elem, true); cout<<""<<endl; wypisz_fp2(); //skasuj_tablice();} ps. chwilowo pokazuje złą cechę ale to zamierzone. Mam nadzieję, że pomożecie mi z tą mantysą. Analizuję kod i naprawdę nie wiem co jest nie tak. Może znajdzie się taka dusza która przetrawi te wypociny.

int rozmiar_tab_calk = 0;int *wsk_rozm_tab_calk = &rozmiar_tab_calk; //int *Tab = new int[*wsk_rozm_tab_calk]; //dynamiczne stworzenie tablicy :)int dec_to_bin(long int a, double b, bool wypisz ){ //konwertujemy while (a > 0) { if(a % 2 != 0) { Tab[*wsk_rozm_tab_calk] = 1; } else { Tab[*wsk_rozm_tab_calk] = 0; } // tablica testowa, jeśli true to wypisuje. if(wypisz == true) { cout << "Tab[" << *wsk_rozm_tab_calk << "]: " << Tab[*wsk_rozm_tab_calk] << endl; } a /= 2; *wsk_rozm_tab_calk += 1; // zmieniam rozmiar tablicy o 1 } return 0;} problem polega na tym, że nigdy nie będę wiedział ile elementów ma mieć moja tablica. Muszę to najpierw policzyć dlatego dobrze byłoby gdybym mógł zmieniać jej rozmiar w trakcie jej działania. Innym sposób to wywołać dwie pętle. W pierwszej pętli policzyć wielkość tablicy a w drugiej przypisywać tej tablicy już wartości. Tylko to zabiera sporo czasu... :) i... sizeof() nie pokazuje odpowiedniej liczby elementów :(

zadeklarowałem funkcję która stworzy mi tablicę wypełnioną 0 lub 1. Za każdym razem tablica może mieć inny rozmiar. int moja_funckja (int x, int y){ int rozmiar = 1; int *wsk_rozmiar = &rozmiar; int Tab[*wsk_rozmiar]; while(warunek) { if(warunek) { Tab[*wsk_rozmiar] = 1; } esle { Tab[*wsk_rozmiar] = 1 } *rozmiar +=1; }}mam potrzebę uzyskania dostępu do tablicy oraz jej rozmiaru ale nie potrafię tego zrobić. Muszę to zrobić aby przekazać tą tablicę oraz jej rozmiar do innej funkcji. Na pewno będzie mi potrzebny wskaźnik, tylko nie umiem go chyba wykorzystać.

Robię rozkład liczby i zapisuję ją tak: double liczba = X;int i=0;int *wsk = &i;Tab[*wsk];while (liczba > 0){ blebleble i++;} W moim przekonaniu dynamicznie przypisuję tablicy Tab rozmiar jaki przekazuje wskaźnik. Czy jest to poprawne?. Czy są jakieś prostsze sposoby na takie tworzenie tablicy?. GCC oraz jakiś windowsowy kompilator puszczają mi to bez problemu. A dodatkowo jak mi pasuje to mogę sobie zrobić coś takiego *wsk + *wsk_inny i także działa. Mam tylko wrażenie, że być może zaśmieca to w jakiś sposób pamięć.

będą 3 komputery ale nie wszystkie będą włączone. Problem polega na tym, że chciałbym aby z każdego komputera móc wydrukować coś na którejkolwiek wybranej drukarce. Myślałem o wykorzystaniu routera i urządzenia print server w takiej konfiguracji: drukarka1->print srv->router-> bezprzewodowe połączenie do routera z każdego komputera (dodatkowo obsługiwany będzie jeszcze internet) drukarka2->print srv->router-> bezprzewodowe połączenie do routera z każdego komputera (dodatkowo obsługiwany będzie jeszcze internet) czy jest jakaś tańsza możliwość, czy tak w ogóle można zrobić aby obsługiwać tyle drukarek na raz?