Jarekz: Utworzono nową stronę " == Język interpretowany vs język kompilowany == Do tej pory pisaliście w pythonie. Jest to język interpretowany. To znaczy wyglądało to tak, że tworzyliście pl..."

2015-05-23T14:06:13Z

Utworzono nową stronę " == Język interpretowany vs język kompilowany == Do tej pory pisaliście w pythonie. Jest to język interpretowany. To znaczy wyglądało to tak, że tworzyliście pl..."

Nowa strona

== Język interpretowany vs język kompilowany ==

Do tej pory pisaliście w pythonie. Jest to język interpretowany. To znaczy wyglądało to tak, że tworzyliście plik tekstowy, zgodnie z określonymi regułami, w którym zapisywaliście kod źródłowy programu. Gdy chcieliście wykonać program, wywoływaliście interpreter pythona podając mu wasz kod źródłowy w postaci tekstowej:
:<tt>python moj_program.py</tt>

W językach kompilowanych (np. <tt>C</tt>, <tt>C++</tt>) po utworzeniu kodu źródłowego uruchamia się program zwany kompilatorem, który w przeciwieństwie do interpretera, nie wykonuje od razu programu, jedynie tworzy
plik z kodem maszynowym. Np.:
:<tt>gcc program.c -o program</tt>
utworzy z naszego kodu źródłowego program.c kod maszynowy program.
Dopiero ten plik jest wykonywalnym programem, zależnym od architektury komputera na którym został utworzony — jest to kod maszynowy zrozumiały dla danej maszyny. Kompilację wystarczy wykonać raz, i nie potrzeba już źródeł do uruchamiania programu wykonywalnego. Jednakże po każdej zmianie kodu źródłowego program należy skompilować jeszcze raz. W przeciwnym razie zmiany te nie zostaną uwzględnione w działaniu programu.

==Program podstawowy==

W podstawowym programie musimy mieć funkcję główną <tt>main</tt> (oraz biblioteki), która zostaje automatycznie wywołana przy uruchomieniu programu.
Składnia funkcji main:
<source lang="c">
int main(int argc, char *argv[], char *envp[])
{

….

return 0;
}
</source>
My będziemy korzystać z takiej:
<source lang="c">
int main(int argc, char *argv[])

{

….

return 0;

}
</source>
Funkcja main jest funkcją zwracającą wartość typu całkowitego (int przed main). Przy wywołaniu programu przekazywane są jej następujące argumenty: <tt>argc</tt> (typu całkowitego) — całkowita liczba przekazanych parametrów oraz tablica typu znakowego (<tt>char *argv[]</tt>), w której zapisane są agrumenty jako napisy (stringi).

Tablice w <tt>C++</tt> oraz <tt>C</tt>, numerowane są od 0 do n-1. Pierwszy argument przekazywany funkcji <tt>main</tt>, czyli <tt>argv[0]</tt>, to nazwa samego programu. <tt>argv[argc-1]</tt> jest ostatnim slowem, ktore wpiszesz, wywolujac program.

Program, jeżeli wykona się poprawnie powinien zwrócić wartość 0 (zaszłości historyczne).
===Pierwszy program w <tt>C++</tt>===
Standardowo pierwszym naszym programem będzie wypisanie "hello world!". Jak to zrobimy w <tt>C++</tt>?
<source lang="c">
#include <iostream>
using namespace std;
int main()
{
cout<<"Hello world"<<endl;
return 0;
}
</source>
Linijka po linijce:

<ol>

<li>
Włączamy nagłówek biblioteki standardowej, której m.in. znajdują
sie polecenia wypisania na ekran.

<li>
Piszemy, że będziemy korzystać z globalnych klas, funkcji i
obiektów, zdefiniowanych w bibliotekach (włączonych).

<li>
Rozpoczynamy funkcję główną — nasz program. Każdy program, żeby
działać musi mieć funkcję główną. Można tez definiować inne funkcje
— będziemy to robić na kolejnych zajęciach. W najprostszym wypadku
nagłówek funkcji main wygląda tak: <tt>int main()</tt>.

<li>
Otwieramy ciało funkcji głównej <tt>{</tt>.

<li>
Wypisujemy na standardowe wyjście napis <tt>Hello world</tt> i
przechodzimy do następnej linijki poleceniem <tt>endl</tt>. Moglibyśmy
też napisać <tt>cout << "Hello world\n";</tt> <tt>"\n"</tt> jest
tzw. znakiem specjalnym.

<li>
Funkcja główna jest funkcją zwracająca liczbę całkowitą. Standardowo (jeżeli program się wykonał poprawnie) zwracamy 0.

<li>
Zamykamy ciało funkcji głownej <tt>}</tt>.

</ol>
===Pierwszy program w <tt>C</tt>===
Standardowo pierwszym naszym programem będzie wypisanie "hello world!". Jak to zrobimy w <tt>C++</tt>?
<source lang="c">
#include <stdio.h>
int main()
{
print("Hello world!\n")
return 0;
}
</source>
Linijka po linijce:

<ol>

<li>
Włączamy nagłówek biblioteki standardowej, której m.in. znajdują
sie polecenia wypisania na ekran.
<li>
Rozpoczynamy funkcję główną — nasz program. Każdy program, żeby
działać musi mieć funkcję główną. Można tez definiować inne funkcje
— będziemy to robić na kolejnych zajęciach. W najprostszym wypadku
nagłówek funkcji main wygląda tak: <tt>int main()</tt>.
<li>
Otwieramy ciało funkcji głównej <tt>{</tt>.
<li>
Wypisujemy na standardowe wyjście napis <tt>Hello world</tt> i
przechodzimy do następnej linijki poleceniem <tt>\n</tt>.
<li>
Funkcja główna jest funkcją zwracająca liczbę całkowitą. Standardowo (jeżeli program się wykonał poprawnie) zwracamy 0.
<li>
Zamykamy ciało funkcji głownej <tt>}</tt>.

</ol>
===Komentarze w tekście programu===
Zarówno w <tt>C</tt> jak i <tt>C++</tt> komentarze jednolinijkowe zaczynają się od podwójnego ukośnika odwrotnego <tt>//</tt>. Komentarze można też zawrzeć w <tt>/*</tt> i <tt>*/</tt>.
===Instrukcja <tt>include</tt>===
Pliki nagłówkowe, zarówno systemowe, jak i autorstwa użytkownika, włącza się za pomocą dyrektywy preprocesora <tt>#include</tt>:
* <tt>#include <plik></tt> używana jest w przypadku systemowych plików nagłówkowych. W tym przypadku plik ''plik'' poszukiwany jest w standardowych katalogach — zwykle w <tt>/usr/include</tt>.
* <tt>#include "plik"</tt> używana jest w przypadku plików nagłówkowych autorstwa użytkownika. Poszukiwane są one na początku w katalogu zawierającym kompilowany program, następnie w katalogach zawartych w cudzysłowach, a następnie w standardowych katalogach, wktórych znajdują się systemowe pliki nagłówkowe.

Nazwa pliku czy w nawiasach trójkątnych, czy w cudzysłowach traktowana jest jako napis. Preprocesor nie rozpoznaje ani znaków wskazujących na rozpoczęcie komentarza (<tt>/*</tt>) ani ukośników odwrotnych, które są traktowane jako zwykłe znaki, a nie znaki specjalne.

== Szybki wstęp do C dla znających pythona -- różnice i podobieństwa ==

=== Uruchamianie programu ===
Python jest językiem interpretowanym, a C kompilowanym. Dlatego też program pythonowy wykonujemy podając jako argument komendzie interpretera plik z kodem źródłowym, który jest następnie interpretowany przez interpreter i wykonywany. Programy pythonowe (a jednocześnie piki z kodem pythonowym) mają rozszerzenie .py.

python moj_program.py

W C plik z kodem źródłowym ma rozszerzenie .c. Aby wykonać program, musimy pier przerobić plik z kodem źródłowym na program -- ciąg bajtów oznaczających instrukcje zrozumiałe już bezpośrednio dla procesora (procesor nie jest w stanie czytać tekstu kodu źródłowego, umie wykonywać proste instrukcje na rejestrach).

gcc moj_program.c -o moj_program

A dopiero potem wykonać program. (Po fladze -o podajemy nazwę jaka ma zostać nadana programowi wykonywalnemu. Domyślnie kompilator utworzy program wykonywalny o nazwie a.out)

./moj_program

=== Struktura programu ===

W programie pythonowym na początku mieliśmy często instrukcje

<source lang="python">
import modul
</source>

W pewnym sensie odpowiednikiem tego w C jest instrukcja:

<source lang="C">
#include <modul>
</source>

W pythonie do funkcji w modułu odwoływaliśmy się:

modul.funkcja_z_modulu()

W C możemy się bezpośrednio do nazwy funkcji odwoałać:

funkcja_z_modułu();

O ile w pythonie większość rzeczy to była konwencja, czyli importy mogliśmy równie dobrze w środku pliku z kodem wpisać, o tyle w C instrukcje include faktycznie muszą być na początku, inazej kompilator zgłosi błąd.

W programie pythonowym mogliśmy pisać dowolne instrukcje w dowolnym miejscu w pliku -- nie było wymogu definiowania żadnych funkcji itd. W programie w C konieczna jest jedna podstawowa funkcja main (opisana trochę wyżej). Tym co już wykona skompilowany program będize właśnie funkcja main. Na zewnątrz tej funkcji możemy sobie podefiniować inne funkcje, i wykonać jeszcze kilka rzeczy ze ściśle określonej puli, jak deklarowanie zmiennych/typów, ale nie możemy już z taką dowolnością jak w pythonie wpisać pętli for w dowolnym miejscu w pliku.

=== Wcięcia i inne podstawowe drobiazgi składniowe ===

W pythonie do oznaczenia bloku programu znajdującego się na tym samym poziomie używamy wcięć. W C możemy wcięcia robić dowolnie, natomiast zakres bloku oznaczamy klamerkami: {}

<source lang="python">
def jakas_funkcja(): # jest dwukropek, komentarz zaznaczamy poprzez #
print "hello world"
</source>

<source lang="c">
#include <stdio.h>
int jakas_funkcja() // nie ma dwukropka, "//" to znak komentarza
{ // blok jest oznaczony nawiasami klamrowi, poniższe wcięcia są tylko dla ładności kodu
printf("Hello world!\n"); // po każdej linijce konieczny jest średnik
return 0;
}
</source>

=== Typy ===

W pythonie nie ma czegoś takiego jak deklaracja zmiennych. Kiedy potrzebujemy zachować sobie w pamięci wynik jakichś operacji, piszemy po prostu:
<source lang = "python">
x = moja_funkcja()
</source>

nie uprzedzając nikogo wcześniej, że będziemy używać takiej zmiennej jak x.

W C już na początku pisania programu trzeba się zdecydować ile zmiennych będziemy używać i jakiego będą typy.
<source lang="C">
int x; //deklaracja zmiennej
x = moja_funkcja();
</source>

Podstawowe typy w C:
{|class="wikitable"
| int
|integer, liczba całkowita zapisana na 32 bitach
|-
|short
|liczba całkowita zapisana na 16 bitach
|-
| long
| liczba całkowita zapisana na 64 bitach
|-
|float
|32 bity
|-
|double
|64 bity (python, którego my używamy jest zaimplementowany w C,<br/> w pythonie do implementacji typu float jest użyty typ double z C)
|-
|char
|character, 1 bajt
|}

=== Podstawowe operacje w C ===

Takie same jak w pythonie:
{|class="wikitable"
|-
| +
|dodawanie
|-
| -
|odejmowanie
|-
| *
|mnożenie
|-
| /
|dzielenie
|-
| =
| operator przypisania wartości
|}

{|class="wikitable"
| <
|mniejszy
|-
| <=
|mniejszy równy
|-
| ==
|równy
|-
| !=
| różny
|-
| >=
|większy równy
|-
| >
|większy
|}

Różnice (operatory logiczne):
{|class="wikitable"
! C
!Python
|-
|&&
|and
|-
| ¦¦
|or
|-
| !
|not
|}

=== Podstawowe konstrukcje: if, while, for ===
W C nie ma typy True i False -- podajemy 0 lub 1, wyrażenia logiczne ewaluują się do 0 lub 1.
<source lang="C">
if (warunek)
{
printf("True \n");
}
else
printf("False\n");
</source>

<source lang="C">

int i = initial_i;

while (i <= i_max)
{
// jakieś instrukcje

i = i + i_increment;
}
</source>

<source lang="C">

for (i = initial_i; i <= i_max; i = i + i_increment)
{
//jakieś instrukcje
}

</source>

=== Funkcje ===

<source lang="C">

typ_zwracany nazwa_funkcji(lista_argumentow)
{
//deklaracje zmiennych lokalnych

//instrukcje

return cos_typu_zwracanego;
}
</source>

na przykład:

<source lang="C">

void fun()
{
printf("fun");
}

</source>

<source lang="C">
int mnozenie(int a, int b)
{
return a * b;
}

</source>

=== Wskaźniki ===
Oto przykład obrazujący czym są wskaźniki:
<source lang="C">
int zmienna_x;
int* wskaznik_na_x;

zmienna_x = 42;
wskaznik_na_x = &zmienna_x;
printf("Wartosc wskaznika: %d, wartosc pod wskaznikiem: %d \n", wskaznik_na_x, *wskaznik_na_x);
*wskaznik_na_x = 0;
printf("wartosc x : %d \n", zmienna_x);

</source>

=== Przykładowy program ===
Program pokazujący jak uważnie trzeba korzystać ze wskaźników:

<source lang="C">
#include <stdio.h>

int test_wskaznikow(int a)

{

int zmienna_x;
int* wskaznik_na_x;

zmienna_x = a;
wskaznik_na_x = &zmienna_x;
printf("Wartosc wskaznika: %d, wartosc pod wskaznikiem: %d \n", wskaznik_na_x, *wskaznik_na_x);
*wskaznik_na_x = 0;
printf("wartosc x : %d \n", zmienna_x);
return wskaznik_na_x;
}

int main(){

int wsk_adres = test_wskaznikow(42);
printf("funkcja uzyla miejsca w pamieci o adresie %d \n", wsk_adres);

return 0;

}

</source>

Ten program nie jest napisany do końca prawidłowo, tzn skompiluje się, ale podczas kompilacji dostaniemy tzw. "warningi", ostrzeżenia, że prawdopodobnie zrobiliśmy coś nie do końca jak należy, ale czysto teoretycznie program w takiej formie mógłby się wykonać:

user-46-113-227-209:~ magda$ gcc test.c
test.c: In function ‘test_wskaznikow’:
test.c:13: warning: format ‘%d’ expects type ‘int’, but argument 2 has type ‘int *’
test.c:16: warning: return makes integer from pointer without a cast

Chodzi o to, że odwołujemy się bezpośrednio do wskaźnika traktując do jako liczbę całkowitą.
Należało by pierw zrzutować go na odpowiedni typ, czyli poprawić następujące linijki:

printf("Wartosc wskaznika: %ld , wartosc pod wskaznikiem: %d \n", (long)wskaznik_na_x, *wskaznik_na_x);

return (long)wskaznik_na_x;

Zauważmy teraz, że wykonanie programu wciąż wygląda podejrzanie:

user-46-113-227-209:~ magda$ ./a.out
Wartosc wskaznika: 140734799804988 , wartosc pod wskaznikiem: 42
wartosc x : 0
funkcja uzyla miejsca w pamieci o adresie 1606416956

Wewnątrz funkcji wypisywany jest dużo dłuższy adres z pamięciu, niż w funkcji main. Dlaczego tak się dzieje? Wskazówka: zwróć uwagę na to, jakiego typu jest wskaźnik wewnątrz funkcji, a jako jaki typ jest traktowany w funkcji main. Co należałoby poprawić?

=== Zadania ===

==== Silnia ====

Napisz program obliczający silnię zadanej liczby N.
Zdefiniuj funkcję silnia, a następnie wywołaj ją w funkcji main. W pierwszym podejściu możesz wartość N wpisać "na sztywno" w kodzie. W drugim podejściu spróbuj pobierać ją jako parametr programu.

==kompilacja (courtesy of wikipedia)==

GCC (ang. GNU Compiler Collection) to zestaw kompilatorów do różnych języków programowania rozwijany w ramach projektu GNU i udostępniany na licencji GPL oraz LGPL. GCC jest podstawowym kompilatorem w systemach uniksopodobnych przy czym szczególnie ważną rolę odgrywa w procesie budowy jądra Linuksa. Początkowo skrótowiec GCC oznaczał GNU C Compiler, ponieważ był to kompilator wyłącznie do języka <tt>C</tt>.

Standardowo używamy kompilator gcc do kompilacji programów napisanych w <tt>C</tt> (rozszerzenie pliku c), a <tt>g++</tt> do kompilacji programów napisanych w <tt>C++</tt> (rozszerzenie pliku <tt>cc</tt>).

Program gcc (wywoływany podczas kompilacji np. z linii poleceń) odpowiada za przetworzenie argumentów, uruchomienie odpowiedniego kompilatora właściwego dla języka programowania w jakim zakodowano plik z kodem źródłowym, wykonanie programu asemblera dla tak otrzymanego wyniku oraz uruchomienie konsolidatora (linkera) w celu uzyskania pliku wykonywalnego. Przykładowo dla pliku napisanego w <tt>C</tt> zostaną wykonane następujące programy: preprocesor <tt>cpp</tt>, kompilator <tt>cc1</tt>, asembler <tt>as</tt> oraz konsolidator <tt>collect2</tt> (dostępny zazwyczaj jako program <tt>ld</tt>).

Przydatne opcje:

<ul>

<li>
<tt>-c</tt>, bez linkowania.

Otrzymujemy pliki obiektowe <tt>*.o</tt>, używamy zwykle gdy nasz program składa się z kilku plików z funkcjami i nagłówkami tychże funkcji (własne biblioteki).

<li>
<tt>-o</tt> (output), podanie nazwy pliku wynikowego:

<tt>g++ -o hello hello.cc</tt>

<li>
<tt>-Wall</tt>
wypisz wszystkie ostrzeżenia (Warnings all)

<li>
<tt>-O</tt> optymalizacja (<tt>-O</tt>, <tt>-O0</tt>, <tt>-O1</tt>, <tt>-O2</tt>, <tt>-O3</tt>, <tt>-Os</tt>)(kolejne stopnie optymalizacji)
<li>
<tt>-g</tt>
tworzy informację potrzebną do debuggowania w naturalnym dla danego
systemu formacie. Debuggujemy zwykle za pomocą <tt>gdb</tt>. Opcji <tt>-g</tt> można
używać z opcją <tt>-O</tt>. gdb można uruchomić w emacsie (dlatego go tak lubimy).
</ul>
===Zadanie===
Napisz dwa programy — <tt>hello.c</tt> i <tt>hello.cc</tt> wypisujące "Hello world!" w terminalu. Skompiluj je i wywołaj. Dodaj do nich komentarze.

TI/Włączanie kodu w innych językach/Języki kompilowalne - Historia wersji

Jarekz: Utworzono nową stronę " == Język interpretowany vs język kompilowany == Do tej pory pisaliście w pythonie. Jest to język interpretowany. To znaczy wyglądało to tak, że tworzyliście pl..."