[frostirosti]

C++ isn't strictly a superset of C! Which I always found crazy. Some C will not compile for C++.

[bobbyi_settv]

It would be hard for it to be a completely strict superset of C because that would require not introducing new reserved words (like "class") since those end up being legal variable names in C but not C++.

[YSFEJ4SWJUVU6]

Why did you find that crazy? They are 2 fully separate languages that have both evolved after the latter (C++) was first introduced.

[EnFinlay]

For people who aren't professionally familiar with C or C++ it's an easy mistake to make considering how often things refer to "C/C++" like they are a single skill.

Example: https://sjobs.brassring.com/TGWebHost/jobdetails.aspx?jobId=...

[jacquesm]

Once upon a time there was this thing called 'cfront'. Cfront took C++ and turned it into C which you then fed through your compiler.

At that time mixing C and C++ was trivial, especially because C++ was still quite simple and the C compiler was the target.

But after that things got more complicated. C evolved, several times in fact since that time and the C++ standard evolved as well. Leading to the impression that C and C++ are merely the old and the improved version of C but it is probably much better to think of them as two distinct species that share a common ancestor, where one of the two had some very radical mutations.

[loeg]

It would be relatively easy for C++ to add some kinds of C compatibility, and they just haven't bothered to. (E.g., the "static" keyword for parameter array sizes.) It's a little annoying for shared headers that have to be used in C and C++ programs.

[dfrey]

When people use the term "C/C++", I assume that they don't know either language well.

[elastic_church]

"5 years of Java/Javascript, with emphasis on PHP"

Contact Pro IT Recruiting where we know our candidates, Referral bonuses too!

[TorKlingberg]

I wouldn't call them "fully separate". Mixed C/C++ codebases are still fairly common, which works as long as the interface between them is in C.

[astrodust]

Mixed C, Objective C and C++ code-bases are still fairly common. That's not to say they're the same language.

[umanwizard]

Well, your argument doesn't really prove anything, as Obj-C is actually much closer to C than C++ is.

[w8rbt]

They have separate ISO standards. IMO, this makes them fully separate.

C - ISO/IEC 9899:2011

C++ - ISO/IEC 14882:2014

[AnimalMuppet]

But the standards have made some effort at avoiding gratuitous incompatibility, and have even introduced changes to reflect changes in the other standard.

Also, much C code is still valid C++. Sure, you can write code that isn't, but I would guess (pulls a number out of nowhere) that 90% of the valid C code is also valid C++.

That makes them languages that have separate standards, but not completely independent standards, that share a whole lot of source code. That's something less than fully separate in my book.

[samfisher83]

Can you provide C code that will not compile with c++ compiler?

[stephencanon]

Besides the various "bad old programming idioms" that do not compile under C++, there are a few genuinely useful features that have only just been added to C++ more than 15 years after they appeared in C, like hexadecimal floating-point literals (in practice, many compilers supported these, but they were not formally part of the language). Designated struct initializers are another C feature that I would love to have in C++.

[hawski]

Compound literals are outside of C++ standard. However GCC for example supports them, but a bit differently [0].

  $ cat foobar.c
  #include <stdio.h>
  
  struct foo {
  	int x;
  	int y;
  };
  
  int foobar(struct foo *f)
  {
  	return f->x + f->y;
  }
  
  int
  main(int argc, char *argv[]) {
  	(void)argc; (void)argv;
  
  	printf("%d\n", foobar(&(struct foo){10, 20}));
  	return 0;
  }
  $ gcc -Wall -Wcast-align -Wextra -pedantic -std=c99 foobar.c -o foobar && ./foobar
  30
  $ g++ -Wall -Wcast-align -Wextra -pedantic foobar.c -o foobar && ./foobar
  foobar.c: In function ‘int main(int, char**)’:
  foobar.c:17: warning: ISO C++ forbids compound-literals
  foobar.c:17: warning: taking address of temporary
  30
  $ # taking address of temporary means that it's undefined behavior

[0] https://gcc.gnu.org/onlinedocs/gcc/Compound-Literals.html

[astrodust]

Here's a bunch of examples: http://www.geeksforgeeks.org/write-c-program-wont-compiler-c...

[Chromozon]

This is a great example of how many of the things in C that don't compile in C++ are horrible programming practices, and it's really nice that C++ doesn't allow such garbage.

[magnusjonsson]

Actually those are very bad examples. In practice, compilers will produce warnings in all of those examples.

Better examples (of actually useful things) would be things like designated initializers, struct literals, declaring array lengths in args using static, etc.

[milesrout]

I don't see what is 'horrible programming practice' about

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

[maccard]

because malloc doesn't return an int, it returns a void

[milesrout]

malloc returns a void pointer because it implicitly converts to an int pointer, as it should.

[msoucy]

Sure:

struct Foo { int virtual; };

[metaobject]

You're being pedantic about reserved words?

[spc476]

I had that same problem. I wrote a C library [1] that has a structure field named "class". It's "class" because the protocol being described (DNS) calls that particular field "class" [2]. And I'm not about to pay lip service to an abomination like C++ [3][4].

[1] https://github.com/spc476/SPCDNS

[2] https://github.com/spc476/SPCDNS/blob/ca5052c3d0c3252071a18e...

[3] I am NOT a fan of C++.

[4] But I had to anyway, but I used the C pre-processor to rename the field.

[camgunz]

Yeah I super hate this. There's no other language that requires other languages to contort themselves like C++ does. Every time I see `#ifdef __cplusplus` or `klass` my blood pressure spikes.

[sampo]

> Can you provide C code that will not compile with c++ compiler?

C99 native complex numbers

[Ace17]

int* p = malloc(256);