Operatory.docx

Operatory:

c=a+b;

c=a:b;  -->  WARNING!!!!

              ":" nie jest rozpoznawalny przez program

Priorytetowość operatorów:

1) ( ), [ ], ->

2) !negacja logiczna,

   ~ inwersja bitowa - zamienia zmienną na system binarny a następnie zamienia 0na1 i 1na0,

   ++, -- działają w pamięci operacyjnej i działają na zmienne  {++k: int a=7;

                                                                                                                      int b=4,c;

                                                                                                                      c=++a+(a+b);

                                                                                                                                8  8 4},

   +, - znak zminnej(jedno argumentowe),

·         - operator wysłuskania,

   & - operator adresu

   (typ) operator konwersji np zmienia typ zmiennej,

   sizeof zwraca wartość w bajtach

3) *(mnożenie)

   \ - dzielenie, jeżeli dane sa calkowite to wynik bedzie calkowity mimo zdefiniowanej zmiennej rzeczywistej, aby to zmienic stosujemy np. a=(float) k/m

   % - reszta z dzielenia (mod)

4) + - (2argumentowe)

5) << >> operatory przesunięcia {k>>3 - przesunięcie bitowe o trzy pozycje w prawo

                                                        00011001

                                                        00000011 - k/2do3

                                                        k<<4 k*2do4

                                                        00110000}

              Przesunięcia:

                            - bitowe

                            - arytmetyczne

                            - cykliczne (co cykl następuje ustalona akcja)

6) >,<,<=,>=

7) ==, !=

8) & - and bitowe

9) ^ - XOR

10) |lub bitowe

11) &&

12) ||

13) ?:                            

14) =, +=, -=, *=

Zestaw 1:

1.X+-Y

X>=0 => X->procesor

inaczej : U1(X)-> procesor

2.(+ i Y>=0) lub (- i Y<0) => Y->Procesor

inaczej: U1(Y) › procesor

Zestaw 2:

1.X->Procesor

2.+ => Y->procesor

inaczej U2(Y)->procesor

Na kod U1 inwersja 0:=1 1:=0 oprócz bitu znakowego.

Na kod U2 dodanie 1.

Konstrukcje strukturalne:

- warunek:

up. if (a>2) a++;

if (a+b>2) a++;                              [else a=10]

else  b=7;

              if (a) b++

                            a!=0

- wyboru:

              Up. switch (a)

              {case 1:a++;

                            b++; break;

              case 2:

              case 7: a=5; break;

              default: a=1; break;

              }

- pętle:

              - for:

                            int a, b, suma;

float c;

for (a=1, b=6, suma=0, c=2,5; (c<10) || (suma<100); b+=4, c++, a+=10, suma+=b+a+c);

for ( ; ; );  à nic nie zrobi ale będzie się wykonywała bez końca

for ( ; ; )

{

}

              - while:

                            int a = 1;

                            while ( a<0);

                            {a++;}

              - do while:

                            int b = 2;

                            do {b++;} while ( b<7);

- tablice:

              - 1-wymiarowa:

                            int tab [10]

                            float t2[] = {7.5,2.7}

                            float t3[10]={};

              - 2-wymiarowa:

                            int t5[3] [7]

- wskaźniki:

              int *wsk, a=5;

              wsk = &a;

printf(„%d”, *wsk);

printf(„%d %d %d”, &wsk,wsk, *wsk);

//dynamiczny przydział pamięci:

wsk = (int *) malloc (sizeof(int));

*wsk = 22;

*wsk = 100; free (wsk);

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

int t[5]={7,2,3,7,11};

int t[3][5] = {…};

int *wsk2;

wsk2 = (int *) malloc (4 * sizeof(int));

              // *(wsk2+i) <-> wsk2[i]

tt1[0] = (int *)malloc(3*4);

for (i = 1; i<3;i++)

              tt1[i] = (int*)malloc(5*4); //krzywa tabela z 3 wierszami ale w pierwszym wierszu 4 kolumny a dalej 5.

free (wsk2);

for (i=0;i<3;i++)

              free (tt1[i]);

tt1[1]=(int*)realloc...