Quais seriam as limitações do C ++ em comparação com a linguagem C?

A seguir estão os benefícios do C ++

  • C ++ fornece os resources específicos sobre os quais eles estão perguntando
  • Seu compilador C é quase certamente um compilador C ++, portanto não há implicações de custo de software
  • C ++ é tão portável quanto C
  • O código C ++ pode ser tão eficiente quanto C (ou mais, ou menos)

Existem algumas razões concretas e cenários específicos, onde é necessário usar C sobre C ++?

Referência a esta pergunta: Biblioteca para genéricos em C

Não é uma duplicata, porque esta pergunta é sobre limitações de linguagem e não sobre deve / não deve aprender uma língua sobre outra.

O post de Peter Kirkham foi para mim o mais informativo, particularmente no que diz respeito às questões do C99 que eu não tinha considerado, então eu aceitei. Obrigado a todos os outros que participaram.

Isto é solicitado por uma resposta que dei a uma questão atual que pergunta sobre uma biblioteca genérica para C – o questionador afirma especificamente que eles não querem usar o C ++.

C é uma linguagem de programação completa. C não é um subconjunto arbitrário de C ++. C não é um subconjunto do C ++.

Isto é válido C:

foo_t* foo = malloc ( sizeof(foo_t) ); 

Para fazê-lo compilar como C ++ você tem que escrever:

 foo_t* foo = static_cast( malloc ( sizeof(foo_t) ) ); 

que não é mais válido. (você poderia usar o estilo C, que seria compilado em C, mas seria evitado pela maioria dos padrões de codificação C ++, e também por muitos programadores C; veja os comentários “não lançar malloc” em todo o Stack Overflow) .


Eles não são do mesmo idioma, e se você tiver um projeto existente em C, não será necessário reescrevê-lo em um idioma diferente apenas para usar uma biblioteca. Você preferiria usar bibliotecas com as quais você possa interagir na linguagem em que está trabalhando. (Em alguns casos, isso é possível com algumas funções extern "C" invólucro extern "C" , dependendo de como o template / inline é uma biblioteca C ++.)

Tomando o primeiro arquivo C em um projeto que estou trabalhando, é isso que acontece se você acabou de trocar gcc std=c99 para g++ :

 sandiego:$ g++ -g -O1 -pedantic -mfpmath=sse -DUSE_SSE2 -DUSE_XMM3 -I src/core -L /usr/lib -DARCH=elf64 -D_BSD_SOURCE -DPOSIX -D_ISOC99_SOURCE -D_POSIX_C_SOURCE=200112L -Wall -Wextra -Wwrite-strings -Wredundant-decls -Werror -Isrc src/core/kin_object.c -c -o obj/kin_object.o | wc -l In file included from src/core/kin_object.c:22: src/core/kin_object.h:791:28: error: anonymous variadic macros were introduced in C99 In file included from src/core/kin_object.c:26: src/core/kin_log.h:42:42: error: anonymous variadic macros were introduced in C99 src/core/kin_log.h:94:29: error: anonymous variadic macros were introduced in C99 ... cc1plus: warnings being treated as errors src/core/kin_object.c:101: error: ISO C++ does not support the 'z' printf length modifier .. src/core/kin_object.c:160: error: invalid conversion from 'void*' to 'kin_object_t*' .. src/core/kin_object.c:227: error: unused parameter 'restrict' .. src/core/kin_object.c:271: error: ISO C++ does not support the 'z' printf length modifier src/core/kin_object.c:271: error: ISO C++ does not support the 'z' printf length modifier 

No total, 69 linhas de erros, quatro das quais são conversões inválidas, mas principalmente para resources que existem no C99, mas não no C ++.

Não é como se eu estivesse usando esses resources para se divertir. Seria necessário um trabalho significativo para transportá-lo para um idioma diferente.

Então é errado sugerir que

[a] compilador C é quase certamente um compilador C ++, portanto não há implicações de custo de software

Muitas vezes há implicações significativas de custo na portabilidade do código C existente para o subconjunto de procedimentos do C ++.

Portanto, sugerir ‘usar a class std :: queue do C ++’ como uma resposta à pergunta ao procurar uma implementação de biblioteca de uma fila em C é mais simples do que sugerir ‘use object C’ e ‘chame a class Java java.util.Queue usando JNI’ ou ‘chame a biblioteca CPython’ – Objetivo C na verdade é um superconjunto adequado de C (incluindo C99), e bibliotecas Java e CPython podem ser chamadas diretamente de C sem ter que portar código não relacionado para a linguagem C ++.

É claro que você poderia fornecer uma fachada C para a biblioteca C ++, mas uma vez que você esteja fazendo isso, o C ++ não é diferente de Java ou Python.

Eu percebo que não é nem profissional nem uma boa resposta em particular, mas para mim é simplesmente porque eu realmente gosto de C. C é pequena e simples e eu posso encheckboxr toda a linguagem em meu cérebro, C ++ para mim sempre pareceu uma grande bagunça com todos os tipos de camadas eu tenho um tempo difícil grokking. Devido a isso eu acho que sempre que eu escrevo C ++ eu acabo gastando muito mais tempo depurando e batendo minha cabeça contra superfícies duras do que quando eu codifico C. Novamente eu percebo que muito disso é em grande parte resultado da minha própria ‘ignorância’.

Se eu escolher, escreverei todas as coisas de alto nível, como a interface e a interação com o database em python (ou possivelmente em C #) e todas as coisas que precisam ser rápidas em C. Para mim, isso me dá o melhor de todos os mundos. Escrever tudo em C ++ parece ter o pior dos mundos.

Edit: Eu gostaria de acrescentar que eu acho que C com alguns resources C ++ é basicamente uma má idéia se você vai ser várias pessoas trabalhando em um projeto ou se a manutenção é prioridade. Haverá desacordo sobre o que constitui um ‘alguns’ e quais bits devem ser feitos em C e quais bits em C ++ levam eventualmente a uma base de código muito esquizofrênica.

O C ++ simplesmente não é suportado em alguns ambientes do mundo real, como sistemas incorporados de baixo nível. E há uma boa razão para isso: C é suficientemente bom para essas coisas, então por que usar algo maior?

Eu odeio programar em C ++.

Algumas razões podem ser:

  • Falta de suporte – Nem todo compilador C é também um compilador C ++. Nem todos os compiladores são particularmente compatíveis com o padrão, mesmo que eles aleguem suportar o C ++. E alguns compiladores de C ++ geram código irremediavelmente inchado e ineficiente. Alguns compiladores têm implementações terríveis da biblioteca padrão. O desenvolvimento no modo kernel geralmente faz com que a biblioteca padrão C ++ seja impossível, assim como alguns resources de linguagem. Você ainda pode escrever o código C ++ se você mantiver o núcleo da linguagem, mas então pode ser mais simples mudar para C.
  • Familiaridade. C ++ é uma linguagem complexa. É mais fácil ensinar alguém C que C ++, e é mais fácil encontrar um bom programador C que um bom programador C ++. (a palavra-chave aqui é “boa”. Existem muitos programadores em C ++, mas a maioria deles não aprendeu a linguagem corretamente)
  • Curva de aprendizado – Como acima, ensinar alguém em C ++ é uma tarefa enorme. Se você está escrevendo um aplicativo que deve ser mantido por outros no futuro, e esses outros podem não ser programadores em C ++, escrevê-lo em C torna muito mais fácil de aprender.

Eu ainda prefiro escrever em C ++ quando posso me safar e, no geral, acho que os benefícios superam as desvantagens. Mas também posso ver o argumento para usar o C em alguns casos.

Existem muitos argumentos sobre programação embarcada, desempenho e outras coisas, eu não os compro. C ++ facilmente compara a C nessas áreas. Contudo:

Apenas recentemente, depois de ter programado em C ++ por mais de 15 anos, eu tenho redescoberto minhas raízes C. Devo dizer que, embora haja bons resources em C ++ que facilitam a vida, há também uma carga de armadilhas e uma espécie de “sempre há uma maneira melhor” de fazer as coisas. Você nunca fica realmente feliz com a solução que você fez. (Não me entenda mal, isso pode ser uma coisa boa, mas principalmente não).

C ++ dá-lhe disparos infinitos. O que poderia ser razoavelmente bom, mas de alguma forma você sempre acaba usando muito disso. Isso significa que você está disfarçando suas soluções com camadas “bonitas” e “bonitas” de abstrações, generalidade, etc.

O que eu descobri, voltando para C, foi que foi divertido programar novamente. Depois de passar tanto tempo modelando e pensando sobre como usar melhor a inheritance, descubro que a programação em C realmente torna meu código-fonte menor e mais legível. Isto é claro, dependendo do seu nível de autodisciplina. Mas é muito fácil colocar muitas abstrações no código direto, o que nunca é realmente necessário.

C tem a principal vantagem de poder ver o que realmente está acontecendo quando você olha para algum pedaço de código (sim, pré-processador: compile com -E e então você o vê). Algo que muitas vezes não é verdade quando você olha para algum código C ++. Lá você tem construtores e destruidores que são chamados implicitamente com base no escopo ou devido a atribuições, você tem sobrecarga de operador que pode ter um comportamento surpreendente mesmo quando não é mal usado. Admito que sou um maníaco pelo controle, mas cheguei à conclusão de que esse não é um hábito tão ruim para um desenvolvedor de software que quer escrever um software confiável. Eu só quero ter uma boa chance de dizer que meu software faz exatamente o que é suposto fazer e não tem um mal-estar no meu estômago ao mesmo tempo, porque eu sei que ainda pode haver tantos bugs nele que eu não faria. nem percebi quando olhei para o código que os causa.

C ++ também tem modelos. Eu os odeio e os amo, mas se alguém diz que os entende, eu os chamo de mentiroso! Isso inclui os criadores de compiladores, bem como as pessoas envolvidas na definição do padrão (que se torna óbvio quando você tenta lê-lo). Há tantos casos de canto absurdamente enganosos envolvidos que simplesmente não é possível considerá-los todos enquanto você escreve o código real. Eu amo modelos C ++ pelo seu poder absoluto. É realmente incrível o que você pode fazer com eles, mas eles também podem levar ao mais estranho e difícil de encontrar erros que se pode (não) imaginar. E esses erros realmente acontecem e nem mesmo raramente. Ler sobre as regras envolvidas para resolver modelos no C ++ ARM quase faz minha cabeça explodir. E isso me dá a sensação ruim de perder tempo tendo que ler mensagens de erro do compilador que têm vários caracteres de 1000 caracteres para os quais eu preciso de 10 minutos ou mais para entender o que o compilador realmente quer de mim. No típico código C ++ (biblioteca), você também encontra muitos códigos nos arquivos de header para tornar certos modelos possíveis, o que torna os ciclos de compilation / execução dolorosamente lentos mesmo em máquinas rápidas e requer recompilation de grandes partes do código quando você muda alguma coisa. há.

C ++ também tem a armadilha const. Você quer evitar const para todos, mas os casos de uso mais triviais ou mais cedo ou mais tarde você terá que descartá-los ou refatorar grandes partes da base de código quando ela evoluir, especialmente quando você estiver prestes a desenvolver um design OO agradável e flexível.

C ++ tem uma tipificação mais forte que C, o que é ótimo, mas às vezes eu sinto que estou alimentando um Tamagotchi quando tento compilar o código C ++. Uma grande parte dos avisos e erros que eu normalmente recebo não são realmente eu fazendo algo que não funcionaria, mas apenas coisas que o compilador não gosta que eu faça dessa forma ou não sem lançar ou colocar algumas palavras-chave extras aqui e há.

Estas são apenas algumas das razões pelas quais eu não gosto de C ++ para software que escrevo sozinho usando apenas algumas bibliotecas externas supostamente robustas. O verdadeiro horror começa quando você escreve códigos em equipes com outras pessoas. Quase não importa se eles são hackers C ++ ou iniciantes ingênuos. Todo mundo comete erros, mas o C ++ torna deliberadamente difícil encontrá-los e ainda mais difícil localizá-los antes que eles aconteçam.

Com C ++, você é simplesmente perdido sem usar um depurador o tempo todo, mas eu gosto de poder verificar a exatidão do meu código na minha cabeça e não ter que confiar em um depurador para encontrar meu código rodando em caminhos que eu nunca teria antecipado. Eu realmente tento executar todo o meu código na minha cabeça e tentar pegar todos os branches que ele tem, mesmo em sub-rotinas, etc. e usar um debugger apenas ocasionalmente apenas para ver como ele funciona em todos os lugares que eu preparei para ele. Escrever e executar tantos casos de teste que todos os caminhos de código foram usados ​​em todas as combinações com todos os tipos de dados de input estranhos é simplesmente impossível. Então você pode não saber dos bugs em programas C ++, mas isso não significa que eles não estejam lá. Quanto maior o tamanho de um projeto C ++, menor a minha confiança de que ele não terá muitos bugs não detectados, mesmo se ele funcionar perfeitamente com todos os dados de teste que tivermos à mão. Eventualmente, eu a destruo e começo de novo com alguma outra linguagem ou combinação de outras linguagens.

Eu poderia continuar, mas acho que deixei claro o meu ponto agora. Tudo isso me fez sentir improdutivo quando eu programo em C ++ e me fez perder a confiança na correção do meu próprio código, o que significa que não vou mais usá-lo, enquanto ainda uso e confio em código C que escrevi mais de 20 anos atrás. Talvez seja simplesmente porque eu não sou um bom programador de C ++, ou talvez ser muito bom em C e outras linguagens me permite reconhecer que eu sou realmente um pouco quando se trata de C ++, e que eu nunca serei capaz de compreendê-lo completamente .

A vida é curta…

Em um ambiente embutido de baixo nível, alguns dos “engenheiros de software” terão um background em EE e mal dominaram C. O C ++ é mais complexo e alguns desses caras simplesmente têm medo de aprender um novo idioma. Assim, C é usado como o menor denominador comum. (Antes de sugerir que você se livre desses caras, eles são pelo menos tão importantes quanto os integrantes do CS que não entendem o material analógico hardcore.)

Falando da experiência em ter herdado e mantido ambos: um design horrível em C é difícil de entender, descontrair e refatorar em algo utilizável.

Um design horrível em C ++ é infinitamente pior à medida que camadas aleatórias de abstração enviam seu cérebro para a base de código tentando descobrir qual código será executado em cada circunstância.

Se eu tiver que trabalhar com engenheiros que conheço não produzirão grandes projetos, prefiro ter o primeiro do que o segundo.

Eu não vejo nenhuma outra razão que não seja a aversão pessoal, mesmo por programar sistemas incorporados e coisas semelhantes. Em C ++, você paga uma sobrecarga apenas pelos resources usados. Você pode usar o subconjunto C do C ++ em algumas situações específicas em que o overhead do C ++ é muito alto para você. Dito isto, acho que alguns programadores de C superestimam a sobrecarga de algumas construções de C ++. Deixe-me listar alguns exemplos:

  • Classes e funções de membro têm zero de sobrecarga em comparação com funções normais (a menos que você use funções virtuais, em cujo caso não há sobrecarga em comparação com o uso de pointers de funções)
  • Os modelos têm muito pouca sobrecarga (na maioria das vezes, nenhuma sobrecarga)

Uma razão válida seria quando você está programando para uma plataforma que não tem um compilador C ++ decente (nenhum compilador C ++, ou um compilador existe, mas é mal implementado e impõe uma alta sobrecarga desnecessária para alguns resources do C ++).

Por que limitar falando em inglês? Talvez você seja um autor mais criativo em sérvio.

Esse é o mesmo argumento, com falácias óbvias. Se você tiver uma tarefa e suas ferramentas confortáveis ​​resolverem a tarefa com eficiência, provavelmente você usará suas ferramentas confortáveis ​​por um bom motivo.

C ++ tem uma curva de aprendizado muito maior. C tem apenas poucas construções que você precisa conhecer e, em seguida, você pode começar a codificar softwares poderosos. Em C ++ você precisa aprender a base C, depois o OO e programação genérica, exceção, etc. E depois de um tempo você pode conhecer a maioria dos resources e você pode usá-los, mas você ainda não sabe como o compilador irá traduzi-los, que sobrecarga implícita eles têm ou não. Isso leva muito tempo e energia.

Para um projeto profissional, este argumento pode não contar, porque você pode empregar pessoas que já conhecem muito bem o C ++. Mas em projetos de código aberto, onde o C ainda é usado, as pessoas escolhem o idioma de que gostam e podem usá-lo. Considere que nem todo programador de SO é um programador profissional.

Eu nunca vi nenhum argumento para usar o C over C ++ que eu consideraria convincente. Eu acho que a maioria das pessoas tem medo de certas funcionalidades que o C ++ oferece, muitas vezes justificadamente. No entanto, isso não me convence, porque é possível impor o uso ou não de determinados resources por meio de padrões de codificação. Mesmo em C, há muito que você gostaria de evitar. Descartando C ++ é essencialmente dizendo que não oferece benefícios tangíveis sobre C que ajudaria a escrever um código melhor, que é uma visão que eu considero bastante ignorante.

Além disso, as pessoas parecem sempre elevar a situação de plataformas onde não existe um compilador C ++. Certamente C seria apropriado aqui, mas acho que seria difícil encontrar uma plataforma como essa nos dias de hoje.

Eu gostaria de seguir a resposta de Dan Olson. Eu acredito que as pessoas temem os resources potencialmente perigosos e contraproducentes do C ++, e justificadamente. Mas ao contrário do que Dan diz, não acho que simplesmente decidir sobre um padrão de codificação seja eficaz, por dois motivos:

  1. Padrões de codificação podem ser difíceis de aplicar estritamente
  2. Pode ser muito difícil encontrar uma boa.

Eu acho que a segunda razão aqui é muito mais importante do que a primeira, porque decidir sobre um padrão de codificação pode facilmente tornar-se um assunto político e ser sujeito a revisão mais tarde. Considere o seguinte caso simplificado:

  1. Você tem permissão para usar contêineres stl, mas não para usar modelos em qualquer um dos seus próprios códigos.
  2. As pessoas começam a reclamar que seriam mais produtivas se tivessem permissão para codificar essa ou aquela class de modelo.
  3. O padrão de codificação é revisado para permitir isso.
  4. Deslize uma inclinação para um padrão de codificação excessivamente complicado que ninguém segue e use exatamente o tipo de código perigoso que a norma deveria evitar, combinado com o excesso de burocracia em torno do padrão.

(A alternativa que o padrão não é revisado no passo 3 é empiricamente improvável demais para ser considerada e não seria muito melhor de qualquer maneira.)

Embora eu usei C ++ para praticamente tudo há alguns anos, estou começando a achar que C é preferível em tarefas de baixo nível que precisam ser manipuladas por C ou C ++ e tudo o mais deve ser feito em outras linguagem inteiramente. (Somente possíveis exceções são alguns domínios de problemas específicos de alto desempenho, wrt. Blitz ++ )

Eu uso C, ou pelo menos exportar uma interface C quando eu escrevo o código da biblioteca.

Eu não quero aborrecimentos da ABI mal definidos.

Um ponto que eu ainda não vi, que eu acho que é o mais importante:

A maioria das bibliotecas que uso diariamente são bibliotecas C com ligações para Python, Ruby, Perl, Java, etc. Pelo que tenho visto, é muito mais fácil agrupar bibliotecas C com 19 ligações de linguagem diferentes do que é envolva bibliotecas C ++.

Por exemplo, aprendi o Cairo uma vez e desde então o usei em 3 ou 4 idiomas diferentes. Grande vitória! Eu prefiro escrever um programa que possa ser usado novamente no futuro, e escrever um que possa ser facilmente adotado para outras linguagens de programação é um caso extremo disso.

Eu sei que é possível ligar bibliotecas C ++, mas o AFAICT não é o mesmo. Eu usei o Qt (v3 e v4) em outras linguagens e não é nem de longe tão agradável de usar: elas parecem escrever C ++ em alguma outra linguagem, não como bibliotecas nativas. (Você tem que passar sigs método C + + como strings!)

C ++ é provavelmente uma linguagem melhor se você estiver escrevendo uma function para ser usada uma vez, ou se você acha que todo o mundo é C ++. C parece ser uma linguagem mais fácil se você estiver projetando para portabilidade de linguagem desde o início.

O desenvolvimento do kernel do Windows não suporta c ++ (infelizmente).

You can read an entertaining rant about why Linus Torvalds favours C here

Native code on a mac is objective-c. Native code on a PC is c (window.h) or c++ (mfc). Both of these environments will let you use c with little or no changes. When I want a library of code to be cross platform ansi c seems like a good choice.

I can think of several reasons.

There may not be a satisfactory C++ compiler. C++ is a much bigger language, and I’ve run C compilers on systems that would not be able to handle modern C++.

The questioner, or people he or she works with, may be familiar with C but not C++.

The project may be in C. While it’s possible to add some C++ features to C, that can easily lead to an unmaintainable mess. I’d suggest picking one language or the other (usually C++, when practical).

The questioner may have an obsolete view of C++’s learning curve. (When approached correctly, it’s easier than C’s. Most introductory books I’ve seen don’t approach it correctly.)

Remember that C and C++ are two different languages, and are getting more different over time. Coding in both at once is a bad idea, and using a C-like subset of C++ misses most of the advantages of C++.

If you work in an environment with two languages, you might use C for some performance critical low-level functions and a more functional/high level language like C#/Java for the business logic. If C++ code is usedfor these functions ,C-Wrappers are required for JNI/unmanaged code around and this makes things more complex than solely using C.

I use C++ with C programming for two reasons:

  • vector and string to get the array memory management away from me
  • strict type checking and casts to warn and/or catch allthe nuisances I would miss otherwise.

So it is C really borrowing a few c++ but using the c++ compiler as much as I can. As someone else says in the answers, I find now I am actually picking up more C++ this way and where C would be too involving, I use C++. Monitor/Lock using RAII is one of these I’ve used recently when dealing with multi-threaded programs and another similar construct to open/close files.

I think C is more portable. I did some work about 5 years ago porting code to many flavours of unix (AIX,Irix,HPUX,Linux). The C code was easy to port but we had various problems porting some of the C++ code across. Maybe it was just immature development environments but i would much rather use C over C++ for this reason…

  1. C is a simple language, C++ is not. For many people, C++ is simply too complicated to fully master, see http://en.wikipedia.org/wiki/C%2B%2B#Criticism .

  2. Because of the complexity, different programmers usually only master different subsets of the language. It makes reading other people’s code painful.

  3. The complexity, pitfalls of the language add too much distraction, and sometimes hurt productivity. Instead of focus on the job itself, I often found myself fighting with the language itself. Java/python are more productive alternatives.

  4. Debugging a broken C code is usually much more straightforward than debugging a broken C++ code.

  5. Unlike Java/C#, the C++ standard library achieves little beyond the scope of the C standard library.

  6. Some famous programmers like Linus Torvalds (Linux) and Richard Stallman (Emacs) dislike C++.

Most programmers take it for granted that everyone considers quality a high priority. That’s not always the case. If you’re use to C, C++ might seem like it’s doing too much for you behind the scenes. The strictness of type checking in C++ might also seem confining. Many people are willing to risk introducing the kinds of bugs that C++ can help prevent to avoid these “nuisances.”

There are three reasons I can think of. One is that C is more suited for embedded systems, due to the small size of its binaries and the wider availability of C compilers on any system. The second is portability: C is a smaller language, and and ANSI C code will compile anywhere. It’s easier to break portability in C++. The last one is the language itself. C++ is harder, and is most definitely a very poorly designed language. Torvalds gripes are reported above. You may also want to look at the C++ Frequently Questioned Answers ( http://yosefk.com/c++fqa/ ).

Portability may be an issue. Different to Gordon Carpenter-Thomp’s answer, I would suggest that it’s rather the runtime support of different versions of libstdc++ on different linux/unix versions. See this link for a good discussion about this. A little excerpt:

The runtime support code used by different parts of a C++ application needs to be compatible. If one part of the program needs to dynamic_cast or catch objects provided by another, both parts must agree on certain implementation details: how to find vtables, how to unwind the stack, and so on.

For C++ and a few other GCC-supported languages with similar features, such details are specified by a C++ ABI. Whenever the ABI used by GCC changes you’ll end up with incompatible libraries produced by the different GCC versions. The same is true for plain C, but the C ABI is much simpler and has been around a lot longer so it’s fairly stable.

I can follow many suggestions here in both directions. But in the end it comes down to a) comparable simple b) comparable complex.

I don’t have an idea if someone has “invented” a sort of language complexity measurement.

On a scale from 0 – 10 I probably would rate C at 2 or 3 whereas C++ would be between 8-10. I’d argue C++ is one of the most complex languages but I do not know eg Ada, PL1 or the like, so maybe it’s not that complex in comparison to some other language.

C++ inherits all complexity of C so it can not be below the complexity level of C.

I for my part would be much more comfortable using some scripting language and C. So in the end one has to answer the following question. “Is more always better?”

The most useful thing I found in C is the lack of namespaces and overloads: function and symbol names are unique identifiers. To find the places where these symbols are used you can just grep through the source code files and search results will shows the locations.

It’s essential when wiring in a new feature or component to an old and tangled system.

You cannot do this easily in C++, without a sophisticated call graph building tool.

Most people seem to think that C and C++ are somehow related, but they are sadly mistaken. C++ is a completely different language than C.

In C++, you think in terms of objects and how they are related to each other. In C, you think in terms of APIs. It’s like the difference between day and 17.

A poor analogy: if someone adds Chinese to English and calls it English++, you probably wouldn’t feel comfortable to add a Chinese line to your latest love letter, because it’s so much easier to express love in this part of English++.

The following are all reasons why it may be beneficial to limit a project to C:

  • faster compilation because the language is much simpler
  • requires less runtime support, making it more suitable low-level environments
  • much easier to interface with other languages
  • supports variable sized arrays on the stack
  • easier to read assembly code because there is no name mangling
  • allows code produced by different compilers to be easily combined since it is the de facto standard application binary interface