Search results
Top results related to c17 (c standard revision) wikipedia english
Top Answer
Answered Feb 21, 2018 · 2 votes
Give this a go:
public static string ToPigLatin(string sentencetext){ string vowels = "AEIOUaeiou"; string cons = "bcdfghjklmnpqrstvwxyzBCDFGHJKLMNPQRSTVWXYZ";- Func<string, string> toPigLatin = word => { word = word.ToLower(); var result = word; Func<string, string, (string, string)> split = (w, l) => { var prefix = new string(w.ToArray().TakeWhile(x => l.Contains(x)).ToArray()); return (prefix, w.Substring(prefix.Length)); }; if (!word.Any(w => cons.Contains(w))) { result = word + "way"; } else { var (s, e) = split(word, vowels); var (s2, e2) = split(e, cons); result = e2 + s + s2 + "ay"; } return result; }; return string.Join(" ", sentencetext.Split(' ').Select(x => toPigLatin(x)));}
The code:
string pigLatin = ToPigLatin("Grrrr Write a method that will convert an English sentence into Pig Latin");Console.WriteLine(pigLatin);-
gives:
grrrray itewray away ethodmay atthay illway onvertcay anay ishenglay entencesay ointay igpay atinlay
1/5
Top Answer
Answered Jul 02, 2012 · 18 votes
The reason is that standard layout types effectively mandate the "empty base class optimization" where base classes with no data members take up no space and have the same address as the first data member (if any) of the derived class.
However, attempting doing this when the base class has the same type as the first data member violates the C++ memory model which requires that distinct objects of the same type must have distinct addresses.
From ISO/IEC 14882:2011 1.8 [intro.object]/6:
Two objects that are not bit-fields may have the same address if one is a subobject of the other, or if at least one is a base class subobject of zero size and they are of different types; otherwise, they shall have distinct addresses
effectively mandating the empty base class, 9.2 [class.mem] /20:
A pointer to a standard-layout struct object, suitably converted using a reinterpret_cast, points to its initial member (or if that member is a bit-field, then to the unit in which it resides) and vice versa.
It would be impossible for the following types (Type1 and Type2) to be layout-compatible (although they would otherwise be standard-layout classes) without this restriction.
struct S1 {};struct S2 {};-struct Type1 : S1 { S1 s; int k;};struct Type2 : S1 { S2 s; int m;};
2/5
Top Answer
Answered Jan 21, 2011 · 48 votes
It's possible you're being lazy or stubborn. Personally, I use them all the time in production code.
I don't do this to be fancy, and I don't do this because I like writing "space-age code." Rather, I do this because I am a paranoid programmer, and I know that production environments are hostile places that will mutilate code and reduce my programs to smoking piles of worthless bytes, if given a chance.
I do this because I live by the motto, "The best code, is the code you never write." It takes time to learn how to use the STL & Std Lib effectively, but once you do you'll find that it can be used so that what now is 1000 lines of code becomes perhaps 100. Those 100 might take as long to write as the original 1000, but there are fewer failure points. The code can be more robust, if you stand on the shoulders of others.
Other Answers
Answered Jan 21, 2011 · 8 votes
You should use stl as much as possible. It has been written by pretty sophisticated programmers and it is very unlikely that you can write a more optimized version of any of stl stuff. Do not re-invent the wheel
Other Answers
Answered Jan 21, 2011 · 6 votes
Just about everyone using C++ uses the STL, especially <algorithm>. You really don't want to have to write sorting functions yourself; you'll just end up making mistakes, and in the end the performance will probably be worse.
Whether or not there are performance gains obviously depends on what you are comparing to. In general though, using the STL algorithms is typically faster than writing your own functions -- unless you happen to have a particular trick that applies to your use case that could give you the edge. If you just write a standard quicksort yourself, it will probably be slower than the one in the STL.
3/5
Top Answer
Answered Oct 13, 2018 · 0 votes
Important Note: You can only use range based for-loops in C++11 or higher if your compiler doesn't support C++11 or higher, use regular for-loops...
Given your question, you have to use this structure (It is equivalent to the one in the question):
typedef struct{ std::string english; std::string pig_latin;} Word;
This is a macro which is going to be used to check if the first letter is a vowel or a consonant (Hence, !IS_VOWEL(some_char))...
#define IS_VOWEL(x) ((x) == 'A' || (x) == 'E' || (x) == 'I' || (x) == 'O' || (x) == 'U' || \ (x) == 'a' || (x) == 'e' || (x) == 'i' || (x) == 'o' || (x) == 'u')
Another function which we need to acquire only the part of the word which has letters (not symbols and numbers):
std::pair<unsigned, unsigned> GetWord(std::string word){ auto start = word.end(); for (auto it = word.begin(); it != word.end(); ++it) if (tolower(*it) >= 'a' && tolower(*it) <= 'z' && start == word.end()) start = it; else if (start != word.end() && !(tolower(*it) >= 'a' && tolower(*it) <= 'z')) return std::make_pair(std::distance(word.begin(), start), std::distance(word.begin(), it)); return std::make_pair(start == word.end() ? 0 : std::distance(word.begin(), start), std::distance(word.begin(), word.end()));}
And last but not least, the function to convert English to Pig-Latin (I know it is huge):
std::vector<Word> CreatePigLatinWordsFromEnglish(std::string english, bool sentence_case = true){ // You can break it from here to use inside another function (viz., splitSentence) std::transform(english.begin(), english.end(), english.begin(), ::tolower); std::stringstream english_stream(english); std::vector<Word> words; std::string temporary; while (std::getline(english_stream, temporary, ' ')) words.emplace_back(Word({ temporary, "" })); // Till here... // From here the conversion starts... for (auto &word : words) { auto const word_it = GetWord(word.english); if (!IS_VOWEL(word.english[word_it.first]) && !std::string(std::next(word.english.begin(), word_it.first), std::next(word.english.begin(), word_it.second)).empty()) { word.pig_latin.append(std::string(word.english.begin(), std::next(word.english.begin(), word_it.first))); word.pig_latin.append(std::string(std::next(word.english.begin(), word_it.first + 1), std::next(word.english.begin(), word_it.second))); word.pig_latin.append(1, word.english[word_it.first]); word.pig_latin.append(std::string("ay")); word.pig_latin.append(std::next(word.english.begin(), word_it.second), word.english.end()); } else word.pig_latin = std::string(word.english.begin(), std::next(word.english.begin(), word_it.second)) + "way" + std::string(std::next(word.english.begin(), word_it.second), word.english.end()); } // Conversion ends here... // Changing the case from lower case to sentence case if needed... if (sentence_case) { words[0].english[0] = toupper(words[0].english[0]); words[0].pig_latin[0] = toupper(words[0].pig_latin[0]); } return words; // Returning the list of words we got...}
Well, an example to demonstrate this method:
int main(){ auto const test = "An apple a day keeps the doctor away!"; for (auto word : CreatePigLatinWordsFromEnglish(test)) std::cout << word.pig_latin << " "; return 0;}
Output:
Anway appleway away ayday eepskay hetay octorday awayway!
Try it out and see whether it gives you the required result...
Kind regards,
Ruks.
4/5
Top Answer
Answered May 23, 2017 · 13 votes
EJP's comments to the question and Steve Summit's answer are exactly to the point: open() is both a syscall and a function in the standard C library; fopen() is a function in the standard C library, that sets up a file handle -- a data structure of type FILE that contains additional stuff like optional buffering --, and internally calls open() also.
In the hopes to further understanding, I shall show hello.c, an example Hello world -program written in C for Linux on 64-bit x86 (x86-64 AKA AMD64 architecture), which does not use the standard C library at all.
First, hello.c needs to define some macros with inline assembly for us to be able to call the syscalls. These are very architecture- and operating system dependent, which is why this only works in Linux on x86-64 architecture:
/* Freestanding Hello World example in Linux on x86_64/x86. * Compile using * gcc -march=x86-64 -mtune=generic -m64 -ffreestanding -nostdlib -nostartfiles hello.c -o hello*/#define STDOUT_FILENO 1#define EXIT_SUCCESS 0#ifndef __x86_64__#error This program only works on x86_64 architecture!#endif#define SYS_write 1#define SYS_exit 60#define SYSCALL1_NORET(nr, arg1) \ __asm__ ( "syscall\n\t" \ : \ : "a" (nr), "D" (arg1) \ : "rcx", "r11" )#define SYSCALL3(retval, nr, arg1, arg2, arg3) \ __asm__ ( "syscall\n\t" \ : "=a" (retval) \ : "a" (nr), "D" (arg1), "S" (arg2), "d" (arg3) \ : "rcx", "r11" )
The Freestanding in the comment at the beginning of the file refers to "freestanding execution environment"; it is the case when there is no C library available at all. For example, the Linux kernel is written the same way. The normal environment we are familiar with is called "hosted execution environment", by the way.
Next, we can define two functions, or "wrappers", around the syscalls:
static inline void my_exit(int retval){ SYSCALL1_NORET(SYS_exit, retval);}static inline int my_write(int fd, const void *data, int len){ int retval; if (fd == -1 || !data || len < 0) return -1; SYSCALL3(retval, SYS_write, fd, data, len); if (retval < 0) return -1; return retval;}
Above, my_exit() is roughly equivalent to C standard library exit()
function, and my_write() to write()
.
The C language does not define any kind of a way to do a syscall, so that is why we always need a "wrapper" function of some sort. (The GNU C library does provide a syscall()
function for us to do any syscall we wish -- but the point of this example is to not use the C library at all.)
The wrapper functions always involve a bit of (inline) assembly. Again, since C does not have a built-in way to do a syscall, we need to "extend" the language by adding some assembly code. This (inline) assembly, and the syscall numbers, is what makes this example, operating system and architecture dependent. And yes: the GNU C library, for example, contains the equivalent wrappers for quite a few architectures.
Some of the functions in the C library do not use any syscalls. We also need one, the equivalent of strlen()
:
static inline int my_strlen(const char *str){ int len = 0L; if (!str) return -1; while (*str++) len++; return len;}
Note that there is no NULL used anywhere in the above code. It is because it is a macro defined by the C library. Instead, I'm relying on "logical null": (!pointer) is true if and only if pointer is a zero pointer, which is what NULL is on all architectures in Linux. I could have defined NULL myself, but I didn't, in the hopes that somebody might notice the lack of it.
Finally, main() itself is something the GNU C library calls, as in Linux, the actual start point of the binary is called _start. The _start is provided by the hosted runtime environment, and initializes the C library data structures and does other similar preparations. Our example program is so simple we do not need it, so we can just put our simple main program part into _start instead:
void _start(void){ const char *msg = "Hello, world!\n"; my_write(STDOUT_FILENO, msg, my_strlen(msg)); my_exit(EXIT_SUCCESS);}
If you put all of the above together, and compile it using
gcc -march=x86-64 -mtune=generic -m64 -ffreestanding -nostdlib -nostartfiles hello.c -o hello-
per the comment at the start of the file, you will end up with a small (about two kilobytes) static binary, that when run,
./hello-
outputs
Hello, world!-
You can use file hello to examine the contents of the file. You could run strip hello to remove all (unneeded) symbols, reducing the file size further down to about one and a half kilobytes, if file size was really important. (It will make the object dump less interesting, however, so before you do that, check out the next step first.)
We can use objdump -x hello to examine the sections in the file:
hello: file format elf64-x86-64helloarchitecture: i386:x86-64, flags 0x00000112:EXEC_P, HAS_SYMS, D_PAGEDstart address 0x00000000004001e1Program Header: LOAD off 0x0000000000000000 vaddr 0x0000000000400000 paddr 0x0000000000400000 align 2**21 filesz 0x00000000000002f0 memsz 0x00000000000002f0 flags r-x NOTE off 0x0000000000000120 vaddr 0x0000000000400120 paddr 0x0000000000400120 align 2**2 filesz 0x0000000000000024 memsz 0x0000000000000024 flags r--EH_FRAME off 0x000000000000022c vaddr 0x000000000040022c paddr 0x000000000040022c align 2**2 filesz 0x000000000000002c memsz 0x000000000000002c flags r-- STACK off 0x0000000000000000 vaddr 0x0000000000000000 paddr 0x0000000000000000 align 2**4 filesz 0x0000000000000000 memsz 0x0000000000000000 flags rw-Sections:Idx Name Size VMA LMA File off Algn 0 .note.gnu.build-id 00000024 0000000000400120 0000000000400120 00000120 2**2 CONTENTS, ALLOC, LOAD, READONLY, DATA 1 .text 000000d9 0000000000400144 0000000000400144 00000144 2**0 CONTENTS, ALLOC, LOAD, READONLY, CODE 2 .rodata 0000000f 000000000040021d 000000000040021d 0000021d 2**0 CONTENTS, ALLOC, LOAD, READONLY, DATA 3 .eh_frame_hdr 0000002c 000000000040022c 000000000040022c 0000022c 2**2 CONTENTS, ALLOC, LOAD, READONLY, DATA 4 .eh_frame 00000098 0000000000400258 0000000000400258 00000258 2**3 CONTENTS, ALLOC, LOAD, READONLY, DATA 5 .comment 00000034 0000000000000000 0000000000000000 000002f0 2**0 CONTENTS, READONLYSYMBOL TABLE:0000000000400120 l d .note.gnu.build-id 0000000000000000 .note.gnu.build-id0000000000400144 l d .text 0000000000000000 .text000000000040021d l d .rodata 0000000000000000 .rodata000000000040022c l d .eh_frame_hdr 0000000000000000 .eh_frame_hdr0000000000400258 l d .eh_frame 0000000000000000 .eh_frame0000000000000000 l d .comment 0000000000000000 .comment0000000000000000 l df *ABS* 0000000000000000 hello.c0000000000400144 l F .text 0000000000000016 my_exit000000000040015a l F .text 000000000000004e my_write00000000004001a8 l F .text 0000000000000039 my_strlen0000000000000000 l df *ABS* 0000000000000000 000000000040022c l .eh_frame_hdr 0000000000000000 __GNU_EH_FRAME_HDR00000000004001e1 g F .text 000000000000003c _start0000000000601000 g .eh_frame 0000000000000000 __bss_start0000000000601000 g .eh_frame 0000000000000000 _edata0000000000601000 g .eh_frame 0000000000000000 _end
The .text section contains our code, and .rodata immutable constants; here, just the Hello, world! string literal. The rest of the sections are stuff the linker adds and the system uses. We can see that we have f(hex) = 15 bytes of read-only data, and d9(hex) = 217 bytes of code; the rest of the file (about a kilobyte or so) is ELF stuff added by the linker for the kernel to use when executing this binary.
We can even examine the actual assembly code contained in hello, by running objdump -d hello:
hello: file format elf64-x86-64-Disassembly of section .text:0000000000400144 <my_exit>: 400144: 55 push %rbp 400145: 48 89 e5 mov %rsp,%rbp 400148: 89 7d fc mov %edi,-0x4(%rbp) 40014b: b8 3c 00 00 00 mov $0x3c,%eax 400150: 8b 55 fc mov -0x4(%rbp),%edx 400153: 89 d7 mov %edx,%edi 400155: 0f 05 syscall 400157: 90 nop 400158: 5d pop %rbp 400159: c3 retq 000000000040015a <my_write>: 40015a: 55 push %rbp 40015b: 48 89 e5 mov %rsp,%rbp 40015e: 89 7d ec mov %edi,-0x14(%rbp) 400161: 48 89 75 e0 mov %rsi,-0x20(%rbp) 400165: 89 55 e8 mov %edx,-0x18(%rbp) 400168: 83 7d ec ff cmpl $0xffffffff,-0x14(%rbp) 40016c: 74 0d je 40017b <my_write+0x21> 40016e: 48 83 7d e0 00 cmpq $0x0,-0x20(%rbp) 400173: 74 06 je 40017b <my_write+0x21> 400175: 83 7d e8 00 cmpl $0x0,-0x18(%rbp) 400179: 79 07 jns 400182 <my_write+0x28> 40017b: b8 ff ff ff ff mov $0xffffffff,%eax 400180: eb 24 jmp 4001a6 <my_write+0x4c> 400182: b8 01 00 00 00 mov $0x1,%eax 400187: 8b 7d ec mov -0x14(%rbp),%edi 40018a: 48 8b 75 e0 mov -0x20(%rbp),%rsi 40018e: 8b 55 e8 mov -0x18(%rbp),%edx 400191: 0f 05 syscall 400193: 89 45 fc mov %eax,-0x4(%rbp) 400196: 83 7d fc 00 cmpl $0x0,-0x4(%rbp) 40019a: 79 07 jns 4001a3 <my_write+0x49> 40019c: b8 ff ff ff ff mov $0xffffffff,%eax 4001a1: eb 03 jmp 4001a6 <my_write+0x4c> 4001a3: 8b 45 fc mov -0x4(%rbp),%eax 4001a6: 5d pop %rbp 4001a7: c3 retq 00000000004001a8 <my_strlen>: 4001a8: 55 push %rbp 4001a9: 48 89 e5 mov %rsp,%rbp 4001ac: 48 89 7d e8 mov %rdi,-0x18(%rbp) 4001b0: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%rbp) 4001b7: 48 83 7d e8 00 cmpq $0x0,-0x18(%rbp) 4001bc: 75 0b jne 4001c9 <my_strlen+0x21> 4001be: b8 ff ff ff ff mov $0xffffffff,%eax 4001c3: eb 1a jmp 4001df <my_strlen+0x37> 4001c5: 83 45 fc 01 addl $0x1,-0x4(%rbp) 4001c9: 48 8b 45 e8 mov -0x18(%rbp),%rax 4001cd: 48 8d 50 01 lea 0x1(%rax),%rdx 4001d1: 48 89 55 e8 mov %rdx,-0x18(%rbp) 4001d5: 0f b6 00 movzbl (%rax),%eax 4001d8: 84 c0 test %al,%al 4001da: 75 e9 jne 4001c5 <my_strlen+0x1d> 4001dc: 8b 45 fc mov -0x4(%rbp),%eax 4001df: 5d pop %rbp 4001e0: c3 retq 00000000004001e1 <_start>: 4001e1: 55 push %rbp 4001e2: 48 89 e5 mov %rsp,%rbp 4001e5: 48 83 ec 10 sub $0x10,%rsp 4001e9: 48 c7 45 f8 1d 02 40 movq $0x40021d,-0x8(%rbp) 4001f0: 00 4001f1: 48 8b 45 f8 mov -0x8(%rbp),%rax 4001f5: 48 89 c7 mov %rax,%rdi 4001f8: e8 ab ff ff ff callq 4001a8 <my_strlen> 4001fd: 89 c2 mov %eax,%edx 4001ff: 48 8b 45 f8 mov -0x8(%rbp),%rax 400203: 48 89 c6 mov %rax,%rsi 400206: bf 01 00 00 00 mov $0x1,%edi 40020b: e8 4a ff ff ff callq 40015a <my_write> 400210: bf 00 00 00 00 mov $0x0,%edi 400215: e8 2a ff ff ff callq 400144 <my_exit> 40021a: 90 nop 40021b: c9 leaveq 40021c: c3 retq
The assembly itself is not really that interesting, except that in my_write and my_exit you can see how the inline assembly generated by the SYSCALL...() macro just loads the variables into specific registers, and does the "do syscall" -- which just happens to be an x86-64 assembly instruction also called syscall here; in 32-bit x86 architecture, it is int $80, and yet something else in other architectures.
There is a final wrinkle, related to the reason why I used the prefix my_ for the functions analog to the functions in the C library: the C compiler can provide optimized shortcuts for some C library functions. For GCC, these are listed here; the list includes strlen().
This means we do not actually need the my_strlen() function, because we can use the optimized __builtin_strlen() function GCC provides, even in freestanding environment. The built-ins are usually very optimized; in the case of __builtin_strlen() on x86-64 using GCC-5.4.0, it optimizes to just a couple of register loads and a repnz scasb %es:(%rdi),%al instruction (which looks long, but actually takes just two bytes).
In other words, the final wrinkle is that there is a third type of function, compiler built-ins, that are provided by the compiler (but otherwise just like the functions provided by the C library) in optimized form, depending on the compiler options and architecture used.
If we were to expand the above example so that we'd open a file and write the Hello, world! into it, and compare low-level unistd.h (open()/write()/close()) and standard I/O stdio.h (fopen()/puts()/fclose()) approaches, we'd find that the major difference is in that the FILE handle used by the standard I/O approach contains a lot of extra stuff (that makes the standard file handles quite versatile, just not useful in such a trivial example), most visible in the buffering approach it has. On the assembly level, we'd still see the same syscalls -- open, write, close -- used.
Even though at first glance the ELF format (used for binaries in Linux) contains a lot of "unneeded stuff" (about a kilobyte for our example program above), it is actually a very powerful format. It, and the dynamic loader in Linux, provides a way to auto-load libraries when a program starts (using LD_PRELOAD environment variable), and to interpose functions in other libraries -- essentially, replace them with new ones, but with a way to still be able to call the original interposed version of the function. There are lots of useful tricks, fixes, experiments, and debugging methods these allow.
5/5
People also ask
What does C17 stand for?
- C17 is the informal name for ISO/IEC 9899:2018, a standard for the C programming language, prepared in 2017 and published in June 2018. It replaced C11 (standard ISO/IEC 9899:2011), and will be superseded by C23 (ISO/IEC 9899:2023) when it is published in 2024.
C17 (C standard revision) - Wikipedia
en.wikipedia.org/wiki/C17_(C_standard_revision)Are there new features in C17?
- So, there are no new features included in C17. The Cppreference (History of C) says: Future development C17 Next minor C language standard revision, will include all accepted C11 defect reports, but no new features. UPDATE:
c - What is C17 and what changes have been made to the language
stackoverflow.com/questions/47529854/what-is-c17-and-what-changes-have-been-made-to-the-languageWhat does C11 stand for?
- C11 (formerly C1X) is an informal name for ISO/IEC 9899:2011, a past standard for the C programming language. It replaced C99 (standard ISO/IEC 9899:1999) and has been superseded by C17 (standard ISO/IEC 9899:2018).
C11 (C standard revision) - Wikipedia
en.wikipedia.org/wiki/C11_(C_standard_revision)What are the changes in C17 compared to C11?
- He identified the following list of changes in C17 compared to C11: atomics: initialization (7.17.2, 7.31.8), coherence requirements (5.1.2.4), fences (7.17.3 p11), functions or macros (7.17.1 p6), lockfree depends on type (7.17.5 p3), compare exchange compares memory and not value (7.17.7.3), atomic_flag (7.17.18).
c - What is C17 and what changes have been made to the language
stackoverflow.com/questions/47529854/what-is-c17-and-what-changes-have-been-made-to-the-languageen.wikipedia.org › wiki › C17_(C_standard_revision)C17 (C standard revision) - Wikipedia
en.wikipedia.org › wiki › C17_(C_standard_revision)C17 is the informal name for ISO/IEC 9899:2018, a standard for the C programming language, prepared in 2017 and published in June 2018. It replaced C11 (standard ISO/IEC 9899:2011), [2] and will be superseded by C23 (ISO/IEC 9899:2023) when it is published in 2024. [3]
- C2x
C23 is the informal name for ISO/IEC 9899:2024, the next...
- C11 (C standard revision)
C11 (formerly C1X) is an informal name for ISO/IEC...
- C2x
stackoverflow.com › questions › 47529854c - What is C17 and what changes have been made to the ...
stackoverflow.com › questions › 47529854Nov 28, 2017 · The Cppreference (History of C) says: Future development. C17 Next minor C language standard revision, will include all accepted C11 defect reports, but no new features. UPDATE: 2018: C17 (ISO/IEC 9899:2018) (ISO Store) (Final draft) Includes the deprecation of ATOMIC_VAR_INIT and the fixes to the following defect reports:
en.cppreference.com › w › cC17 - cppreference.com
en.cppreference.com › w › cApr 5, 2022 · C17. ISO/IEC 9899:2018, a.k.a. C17 / C18 (denote the year of completion and publication respectively), is the current revision of the C standard. C17 is same as C11, except that it bumps the __STDC_VERSION__ predefined macro to 201710L, contains several defect reports, and deprecates some features.
en.cppreference.com › w › cHistory of C - cppreference.com
en.cppreference.com › w › cMay 23, 2024 · 1973: Unix re-written in C unsigned, long, union, enumerations, increased type safety 1978: The C Programming Language, 1st edition Standard C. 1983: ANSI established X3J11 committee 1988: The C Programming Language, 2nd edition 1989: C89, the ANSI C standard published codified existing practices
dbpedia.org › page › C17_(C_standard_revision)About: C17 (C standard revision) - DBpedia Association
dbpedia.org › page › C17_(C_standard_revision)C17 is the informal name for ISO/IEC 9899:2018, the most recent standard for the C programming language, prepared in 2017 and published in June 2018. It replaced C11 (standard ISO/IEC 9899:2011). C17 will be superseded by C2x. Since it was under development in 2017, and officially published in 2018, C17 is also commonly referred to as C18.
Searches related to c17 (c standard revision) wikipedia english
