Czy C jest silnie wpisane?

Cytując Wikipedię :

Dwa powszechnie używane języki, które obsługują wiele rodzajów niejawnej konwersji to C i C ++ i czasami twierdzi się, że są to języki słabo typowane. Jednak inni twierdzą, że języki te nakładają wystarczające ograniczenia na sposób mieszania operandów różnych typów, że oba te języki należy traktować jako języki silnie typowane.

Czy jest bardziej ostateczna odpowiedź?

„Silnie wpisane” i „słabo wpisane” to terminy, które nie mają szeroko uzgodnionego technicznego znaczenia. Terminy, które mają dobrze zdefiniowane znaczenie

• Typ dynamiczny oznacza, że ​​typy są dołączane do wartości w czasie wykonywania, a próba zmieszania wartości różnych typów może spowodować „błąd typu w czasie wykonywania”. Na przykład, jeśli w Scheme spróbujesz dodać jeden do true, pisząc (+ 1 #t), spowoduje to błąd. Błąd występuje tylko wtedy, gdy próbujesz wykonać niewłaściwy kod.

• Typ statyczny oznacza, że ​​typy są sprawdzane w czasie kompilacji, a program, który nie ma typu statycznego, jest odrzucany przez kompilator. Na przykład, jeśli w ML spróbujesz dodać jeden do true przez zapis 1 + true, program zostanie odrzucony z (prawdopodobnie tajemniczym) komunikatem o błędzie. Zawsze pojawia się błąd, nawet jeśli kod może nigdy nie zostać wykonany.

Różni ludzie preferują różne systemy po części ze względu na to, jak bardzo cenią sobie elastyczność i jak bardzo martwią się błędami w czasie wykonywania.

Czasami określenie „silnie wpisane” jest używane luźno na oznaczenie „wpisane statycznie”, a „słabo wpisane” jest używane niepoprawnie, aby oznaczać „wpisane dynamicznie”. Lepszym zastosowaniem terminu „silnie typowany” jest to, że „nie można obejść lub obalić systemu typów”, podczas gdy „słabo wpisany” oznacza „istnieją luki w systemie typów”. Przewrotnie, większość języków ze statycznymi systemami typów ma luki, podczas gdy wiele języków z dynamicznymi systemami typów nie ma luk.

Żaden z tych terminów nie jest w żaden sposób powiązany z liczbą niejawnych konwersji dostępnych w języku.

Jeśli chcesz mówić dokładnie o językach programowania, najlepiej unikać terminów „silnie wpisane” i „słabo wpisane”. Powiedziałbym, że C to język, który jest zapisywany statycznie, ale ma wiele luk. Jedną z luk jest to, że możesz dowolnie rzutować dowolny typ wskaźnika na dowolny inny typ wskaźnika. Możesz także utworzyć lukę między dowolnymi dwoma wybranymi typami, deklarując związek C, który ma dwóch członków, po jednym dla każdego z typów, o których mowa.

Więcej o statycznym i dynamicznym typowaniu pisałem w artykule Why-interpreted-langs-are-Most-ducktyped-while-compiled-have-strong-typing .

Trudno jest sklasyfikować każdy język jako „słabo” lub „silnie” typowany - to raczej kontinuum. Ale w porównaniu z innymi językami C jest dość silnie wpisane na maszynie. Każdy obiekt ma typ czasu kompilacji, a kompilator poinformuje Cię (głośno), jeśli robisz coś z obiektem, na co nie pozwala jego typ. Na przykład nie można wywoływać funkcji z niewłaściwymi typami parametrów, uzyskać dostępu do nieistniejących członków struktury / unii itp.

Ale jest kilka słabości. Jedną z głównych słabości są typy typów - zasadniczo mówią, że będziesz grzebać w typach obiektów, a kompilator powinien być cichy (jeśli może). void*to także kolejna słabość - jest to ogólny wskaźnik do nieznanego typu, a kiedy ich używasz, musisz być szczególnie ostrożny, aby postępować właściwie. Kompilator nie może statycznie sprawdzić większości zastosowań void*. void*można również przekonwertować na wskaźnik do dowolnego typu bez rzutowania (tylko w C, nie w C ++), co jest kolejną słabością.

Literatura nie jest tego jasna. Myślę, że silnie wpisane nie jest tak / nie, istnieją różne stopnie silnego pisania.

Język programowania ma specyfikację sposobu wykonywania programów. Czasami nie jest jasne, jak wykonać określone programy. Na przykład programy, które próbują odjąć ciąg znaków od liczby. Lub programy, które dzielą przez zero. Istnieje kilka sposobów radzenia sobie z tymi warunkami. Niektóre języki mają reguły postępowania z takimi błędami (na przykład zgłaszają wyjątek). Inne języki po prostu nie mają reguł radzenia sobie w takich sytuacjach. Te języki na ogół mają systemy typów, które zapobiegają kompilowaniu programów, które prowadzą do nieokreślonego zachowania. Istnieją również języki, które mają nieokreślone zachowanie i nie mają systemu typów zapobiegającego tym błędom w czasie kompilacji (jeśli napiszesz program, który osiąga nieokreślone zachowanie, może on wystrzelić pociski).

Więc:

Języki, które określają, co dzieje się w czasie wykonywania w każdym przypadku (na przykład dodawanie liczby do ciągu), nazywane są dynamicznie typowanymi. Języki, które uniemożliwiają wykonywanie programów z błędami w czasie kompilacji, są wpisywane statycznie. Języki, które nie określają, co się dzieje, a także nie mają systemu typów zapobiegającego błędom, nazywane są słabo wpisanymi.

Czy więc Java jest wpisywana statycznie? Tak, ponieważ jego system typów nie pozwala na odejmowanie ciągu znaków od liczby. Nie, ponieważ umożliwia dzielenie przez zero. Możesz zapobiec dzieleniu przez zero w czasie kompilacji w systemie typów. Na przykład tworząc typ liczbowy, który nie może być zerem (np. NonZeroInt) i pozwala na dzielenie tylko przez liczby, które mają ten typ.

Czy więc C jest wpisane silnie czy słabo? C jest silnie wpisane, ponieważ system typów nie zezwala na niektóre błędy typu. Ale jest słabo wpisany w innych przypadkach, gdy nie jest zdefiniowane, co się dzieje (a system typów cię nie chroni).

C jest uważane za słabo wpisane, ponieważ można przekonwertować dowolny typ na dowolny inny typ poprzez rzutowanie, bez błędu kompilatora. Więcej na ten temat przeczytasz tutaj .

C jest silniej wpisane niż JavaScript i mniej silnie wpisane niż Ada.

Powiedziałbym, że bardziej pasuje do silnie wpisanej strony kontinuum. ale ktoś inny może się nie zgodzić (nawet jeśli się myli).

Jak to jest ostateczne?

C jest uważane za statycznie typowane (nie możesz zmienić zmiennej z int na float). Po zadeklarowaniu zmiennej utknie w ten sposób.

Ale jest uważany za słabo wpisany, ponieważ typy można przerzucić na flopie.

Co to jest 0? '\ 0', FALSE, 0.0 itd.

w wielu językach nie można powiedzieć JEŻELI (zmienna), ponieważ warunki będą przyjmować tylko wartości logiczne z wyrażeń boolowskich. Te są silniej wpisane. To samo dotyczy przechodzenia między znakami i liczbami całkowitymi.

zasadniczo c ma dwa główne proste typy danych, liczby całkowite i liczby zmiennoprzecinkowe (choć z różnymi dokładnościami). Wszystkie inne wartości logiczne, wyliczenia (nie proste, ale pasujące) itp. Są zaimplementowane jako jedne z nich. Nawet znaki są w zasadzie liczbami całkowitymi.

Porównaj z innymi językami, w których istnieją typy ciągów, typy wyliczeniowe, które można przypisać tylko do zdefiniowanych wartości, typy logiczne, w których można używać tylko wyrażeń generujących wartości logiczne lub prawda / fałsz.

Ale można argumentować, że w porównaniu do Perl C jest silnie wpisany. Jest to więc jeden z tych słynnych argumentów (vi vs emacs, linux vs windows, itp.). C # jest silniejszym typem niż C. Zasadniczo można dyskutować w obie strony. Twoje odpowiedzi prawdopodobnie pójdą w obie strony :) Również w niektórych podręcznikach / stronach internetowych będzie napisane, że C jest napisane słabo, a inne powiedzą, że C jest napisane silnie. Jeśli przejdziesz do wikipedii, wpis w C mówi „częściowo słabe pisanie”. Powiedziałbym, że w porównaniu do Pythona C jest napisany słabo. Więc Python / C #, C, Perl na kontinuum.

Wiele dobrych odpowiedzi. Chcę poruszyć ważny punkt z Real World Haskell :

Warto mieć świadomość, że wiele społeczności językowych ma własne definicje „silnego typu”. Niemniej jednak omówimy krótko i ogólnie pojęcie siły w systemach czcionek.

(fantastyczna okazja)

Fajerwerki wokół systemów czcionek mają swoje korzenie w zwykłym angielskim, gdzie ludzie przypisują wartościowe słowa „słaby” i „silny”: zazwyczaj myślimy o sile jako lepszej niż słabości. O wiele więcej programistów mówi prostym językiem niż żargonem akademickim, i dość często akademicy naprawdę rzucają cegiełkami w każdy system typów, który nie odpowiada ich wyobraźni. Rezultatem jest często ta popularna rozrywka internetowa, wojna o płomienie.

Spójrz więc na odpowiedzi dotyczące C i C ++, ale pamiętaj, że „mocne” i „słabe” nie są odwzorowywane na „dobre” i „złe”.

Według Dennisa Ritchiego ( twórcy C ) i Briana Kernighana, C nie jest językiem silnie typowanym. Poniższe wiersze pochodzą z książki Język programowania C, strona 3, paragraf 5

C nie jest językiem silnie typizowanym, ale w miarę ewolucji jego sprawdzanie typów zostało wzmocnione.

Moim zdaniem C / C ++ są silnie wpisane. Typy hacków, które pozwalają na konwersję typów (void *), są spowodowane bliskością C do maszyny. Innymi słowy, możesz wywoływać polecenia asemblera z Pascala i manipulować wskaźnikami, a Pascal jest nadal uważany za język silnie typizowany. Możesz wywoływać pliki wykonywalne assemblera i C z Java poprzez JNI, ale nie powoduje to słabego typowania Java.

C ma po prostu „osadzony” asembler z surowymi wskaźnikami i tym podobne.

Termin silnie wpisany na maszynie nie ma uzgodnionej definicji. Dlatego jeśli nie zdefiniujesz, co masz na myśli przez „mocno wpisane”, nie możesz odpowiedzieć na twoje pytanie.

Z mojego doświadczenia wynika , że terminy „silnie wpisane” i „słabo wpisane” są używane wyłącznie przez trolle, ponieważ ich brak definicji pozwala trollom na przedefiniowanie ich w trakcie dyskusji, aby dopasować się do ich programu. Poza rozpoczęciem ostrzału, terminy te są prawie bezużyteczne.

Możesz również rzucić okiem na jakie są kluczowe aspekty silnie wpisywanego języka? tutaj w StackOverflow.

Istnieje ciągłość z wieloma równoległymi ścieżkami między „słabo wpisanymi” i „silnie wpisanymi”, dwoma terminami, które nie są nawet dobrze zdefiniowane.

C jest wpisywane statycznie, co oznacza , że kompilator wie, jaki jest zadeklarowany typ każdej zmiennej lokalnej i elementu członkowskiego struktury.

Języki z typami dynamicznymi mogą nadal być silnie wpisane, jeśli każdy obiekt ma określony typ, ale kompilator nie ma możliwości poznania tego typu.

Jaki jest powód Twojego zapytania? Powodem, dla którego pytam, jest niewielka różnica, a twoje szczególne użycie „silnie wpisanego” może wymagać mniej lub więcej wyjaśnienia. Zdecydowanie powiedziałbym, że Java i inne języki mają ściślejsze ograniczenia dotyczące niejawnej konwersacji typu.

Trudno jest udzielić konkretnej odpowiedzi, gdy nie ma konkretnej definicji „silnie wpisanej na maszynie”. Powiedziałbym, że C jest silnie wpisane, że każda zmienna i każde wyrażenie ma typ, ale słabo wpisane, co pozwala na zmianę typów za pomocą rzutowania i reinterpretację reprezentacji jednego typu jako drugiego.

Powiedziałbym, że C jest tak silnie wpisane, jak dyktuje twój kompilator / platforma. Na przykład, jeśli budujesz na ścisłej platformie, wyłuskiwanie wskaźnika typu przebijanego prawdopodobnie się zepsuje:

void m_free(void **p)
{
        if (*p != NULL) {
                free(*p);
                *p = NULL;
        }
}

....
char *str = strdup("foo");
m_free((void **) &foo);

Teraz, jeśli powiesz kompilatorowi, aby pominął ścisłe aliasowanie, nie byłoby to problemem, ale niezbyt przenośnym. W tym sensie przesuwanie granic języka jest możliwe, ale prawdopodobnie nie jest najlepszym pomysłem. To wykracza poza typowe casting, tj. Casting int tak długo i naprawdę pokazuje jedną z możliwych pułapek void.

Więc powiedziałbym, że C jest w zasadzie ściśle typowane, ale jego różne kompilatory zakładają, że programista wie najlepiej i pozwala na pewną elastyczność. To naprawdę zależy od kompilatora, niektórzy nie wychwycą tego potencjalnych błędów. W tym sensie wybrany kompilator naprawdę odgrywa rolę przy udzielaniu odpowiedzi na pytanie. To, co jest poprawne, często różni się od tego, na co pozwala kompilator.

c jest napisane słabo, b jest bez typu.

Niezbyt mocno wpisane.

Zastanów się, co poniższy prototyp funkcji mówi o typach danych argumentów:

void func (int n, char ch, ...);

Nic. Sugeruję więc, że mocne pisanie tutaj nie ma zastosowania.

Powiedziałbym, że jest to typ silnie typowy, ponieważ każde wyrażenie ma typ, który nie jest funkcją jego wartości; ei można to poznać przed uruchomieniem.

OTOH Nie jestem pewien, czy jest to poprawny opis silnie wpisanego. Jedynym silniejszym twierdzeniem, jakie widzę dla języka, jest zapewnienie, że nie można obalić systemu typów w czasie wykonywania poprzez reinterpretację rzutowania typów, związków, wywołań do innych języków, wskaźników, języka asemblera itp. Języki takie jak ten istnieją, ale są tak okaleczeni, że wydają się nie interesować programistów spoza środowiska akademickiego i akademickiego. Jak ktoś zauważył, aby naprawdę zrobić to dobrze, musisz mieć takie typy nonZeroInti inne. Fuj.