Es C inflexible?

Es difícil clasificar cada idioma en' débilmente 'o' fuertemente ' escrito's es más bien un continuo. Pero, en comparación con otros idiomas, C está bastante fuertemente escrito. Cada objeto tiene un tipo en tiempo de compilación, y el compilador le informará (en voz alta) si está haciendo algo con un objeto que su tipo no le permite hacer. Por ejemplo, no puede llamar a funciones con los tipos de parámetros incorrectos, acceder a miembros de struct / union que no existen, etc.

Pero hay algunos debilidad. Una debilidad importante son los encasillamientos - esencialmente dicen que vas a estar jugando con los tipos de objetos, y el compilador debería estar tranquilo (cuando pueda). void* es también otra debilidad: es un puntero genérico para un tipo desconocido, y cuando se utilizan, tienen que tener mucho cuidado de que estás haciendo lo correcto. El compilador no puede comprobar estáticamente la mayoría de los usos de void*. void* también se puede convertir en un puntero a cualquier tipo sin un cast (solo en C, no en C++), lo cual es otra debilidad.

Se considera que C está débilmente escrito, porque puede convertir cualquier tipo a cualquier otro tipo a través de un cast, sin un error del compilador. Puede leer más sobre el tema aquí.

La literatura no es clara sobre esto. Creo que fuertemente mecanografiado no es sí / no, hay diversos grados de mecanografía fuerte.

Un lenguaje de programación tiene una especificación de cómo ejecuta programas. A veces no está claro cómo ejecutar con ciertos programas. Por ejemplo, programas que intentan restar una cadena de un número. O programas que dividen por cero. Hay varias maneras de lidiar con estas condiciones. Algunos idiomas tienen reglas para tratar estos errores (para ejemplo lanzan una excepción). Otros idiomas simplemente no tienen reglas para lidiar con estas situaciones. Esos lenguajes generalmente tienen sistemas de tipos para evitar la compilación de programas que conducen a un comportamiento no especificado. Y también existen lenguajes que tienen un comportamiento no especificado y no tienen un sistema de tipos para prevenir estos errores en tiempo de compilación (si escribes un programa que golpea un comportamiento no especificado podría lanzar los misiles).

Entonces:

Idiomas que especifican lo que sucede en el tiempo de ejecución en todos los casos (como agregar un número a una cadena) se llama dinámicamente escrito. Los lenguajes que impiden ejecutar programas con errores en tiempo de compilación se escriben estáticamente. Los idiomas que no especifican lo que sucede y tampoco tienen un sistema de tipos para evitar errores se denominan débilmente tipeados.

¿Entonces Java se escribe estáticamente? Sí, porque su sistema de tipos no permite restar una cadena de un número. No, porque te permite dividir por cero. Usted podría evitar la división por cero en tiempo de compilación con un sistema de tipos. Por ejemplo, creando un tipo de número que no puede ser cero (por ejemplo, no punto), y solo permite dividir por números que tienen este tipo.

Entonces, ¿C está fuertemente tipeado o débilmente tipeado? C se escribe fuertemente porque el sistema de tipos no permite algunos errores de tipo. Pero se escribe débilmente en otros casos cuando no está definido lo que sucede (y el sistema de tipos no lo protege).

C se escribe más fuertemente que Javascript y menos fuertemente que Ada.

Diría que cae más en el lado fuertemente escrito del continuum. pero alguien más podría estar en desacuerdo (incluso si están equivocados).

¿Cómo es eso definitivo?

C se considera escrito estáticamente (no se puede tener un cambio de variable de int a float). Una vez que se declara una variable se atasca de esa manera.

Pero se considera débilmente tipeado porque los tipos pueden ser volteados.

¿Qué es 0? '\0', FALSE, 0.0, etc..

En muchos idiomas no se puede decir IF (variable) porque las condiciones solo tomarán valores booleanos de expresiones booleanas. Estos son más fuertemente tipeados. Lo mismo se aplica a ir entre caracteres y entero.

Básicamente c tiene dos tipos de datos simples principales, enteros y números de coma flotante (aunque varias precisiones). Todo lo demás booleanos, enumeraciones (no es simple pero encaja), etc. se implementan como uno de ellos. Incluso los caracteres son básicamente enteros.

Compare con otros lenguajes donde hay tipos de cadena, tipos de enumeración que solo se pueden asignar a los valores definidos, tipos booleanos donde solo se pueden usar expresiones que generen booleanos o true/false.

Pero se puede argumentar que en comparación con Perl C se escribe fuertemente. Así que es uno de esos famosos argumentos (vi vs emacs, linux vs windows, etc.). C# se escribe más fuerte que C. Básicamente se puede argumentar de cualquier manera. Y sus respuestas probablemente irán en ambos sentidos:) También algunos libros de texto / páginas web dirán que C está débilmente escrito, y algunos dirán que C está fuertemente escrito. Si vas a wikipedia la entrada C dice "tipeo parcialmente débil". Yo diría que comparado con Python C está débilmente escrito. Así que Python / C#, C, Perl en el continuum.

Muchas buenas respuestas aquí. Quiero traer un punto importante de Real World Haskell :

Es útil tener en cuenta que muchas comunidades lingüísticas tienen sus propias definiciones de "tipo fuerte". Sin embargo, hablaremos brevemente y en términos generales sobre la noción de fuerza en los sistemas de tipos.

(snip)

Los fuegos artificiales alrededor de los sistemas de tipos tienen sus raíces en el inglés ordinario, donde la gente atribuye nociones de valor a la palabras "débil" y "fuerte": por lo general pensamos en la fuerza como mejor que la debilidad. Muchos más programadores hablan un inglés sencillo que la jerga académica, y muy a menudo los académicos realmente están lanzando brickbats a cualquier tipo de sistema que no se adapte a su fantasía. El resultado es a menudo ese pasatiempo popular de Internet, una guerra de llamas.

Entonces, mira las respuestas sobre C y C++, pero recuerda que 'fuerte' y 'débil' no se asignan a 'bueno' y 'malo'.

En mi opinión, C/C++ están fuertemente tipeados. El tipo de hacks que permiten convertir tipos (void*) está ahí debido a la cercanía de C a la máquina. En otras palabras, puede llamar a comandos ensambladores desde Pascal y manipular punteros y Pascal todavía se considera como un lenguaje fuertemente escrito. Puede llamar a ensamblador y ejecutables de C desde Java a través de JNI, pero no hace que Java se escriba débilmente.

C solo tiene ensamblador "incrustado" en él con punteros raw y tal.

El término fuertemente escrito no tiene una definición acordada. Por lo tanto, a menos que defina lo que quiere decir por "fuertemente escrito", es imposible responder a su pregunta.

En mi experiencia, los términos "fuertemente mecanografiados" y "débilmente mecanografiados" son utilizados exclusivamente por los trolls, porque su falta de definiciones permite a los trolls redefinirlos a mitad del argumento para adaptarse a su agenda. Aparte de iniciar flamewars, estos términos son más o menos inútil.

Es posible que también desee echar un vistazo a ¿Cuáles son los aspectos clave de un lenguaje fuertemente escrito? aquí en StackOverflow.

Según Dennis Ritchie ( creador de C) y Brian Kernighan , C no es un lenguaje fuertemente escrito. Las siguientes líneas son del libro El lenguaje de programación C página 3 párrafo 5

C no es un lenguaje fuertemente tipado, pero a medida que ha evolucionado, su comprobación de tipos se ha fortalecido.

Hay un continuo con múltiples vías paralelas entre "débilmente tipeado" y "fuertemente tipeado", dos términos que ni siquiera están bien definidos.

C se escribe estáticamente, ya que el compilador sabe cuál es el tipo declarado de cada variable local y miembro de la estructura.

Los lenguajes tipeados dinámicamente pueden estar fuertemente tipeados, si cada objeto tiene un tipo específico, pero no hay forma de que el compilador conozca ese tipo.

C se escribe débilmente, b no se escribe.

¿Cuál es el motivo de su consulta? La razón por la que pregunto es que esta es una especie de diferencia menor y su uso particular de "fuertemente mecanografiado" podría necesitar más o menos aclaración. Definitivamente diría que Java y otros lenguajes tienen restricciones más estrictas en la conversación de tipo implícito.

Es difícil dar una respuesta concreta cuando no hay una definición concreta de "inflexible". Yo diría que C está fuertemente tipeado en que cada variable y cada expresión tiene un tipo, pero débilmente tipeado en que le permite cambiar tipos utilizando moldes y reinterpretar la representación de un tipo como otro.

Yo diría que C está tan fuertemente escrito como lo dicta su compilador / plataforma. Por ejemplo, si está construyendo en una plataforma estricta, es probable que la desreferenciación de un puntero de tipo punned se rompa:

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

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

Ahora, si le dijeras al compilador que omita el alias estricto, no sería un problema, pero no muy portable. Así que, en ese sentido, empujar los límites del lenguaje es posible, pero probablemente no la mejor idea. Eso va un paso más allá del casting típico, es decir, casting int tan largo y realmente muestra una de las posibles trampas del vacío.

Por lo tanto, yo diría que C es básicamente estrictamente tipado, pero sus diversos compiladores suponen que el programador sabe mejor y permite cierta flexibilidad. Esto realmente depende del compilador, algunos no captarían ese potencial oops. Así que en ese sentido, el compilador de elección realmente juega un papel al responder la pregunta. Lo que es correcto a menudo difiere de lo que su compilador le permitirá salirse con la suya.

No fuertemente escrito.

Considere lo que el siguiente prototipo de función le dice sobre los tipos de datos de los argumentos:

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

Nada. Así que sugiero que la escritura fuerte no se aplica aquí.

Yo diría que es fuertemente tipos, ya que cada expresión tiene un tipo que no es una función de su valor; es decir, se puede conocer antes del tiempo de ejecución.

OTOH No estoy seguro de que sea la descripción correcta de strongly typed. La única afirmación más fuerte que puedo ver por qué un lenguaje hacer sería la garantía de que no se puede subvertir el sistema de tipos en tiempo de ejecución a través de reinterpretar casts de tipos, uniones, llamadas a otros idiomas, punteros, lenguaje ensamblador, etc. Idiomas como este existen pero son tan paralizado que parecen no ser de mucho interés para los programadores fuera de la alta garantía y la academia. Como ha señalado alguien, para hacer eso bien empiezas a necesitar tipos como nonZeroInt y demás. Qué asco.