没有头文件的C/ c++程序

I was wondering if there is any possible way to write C/C++ program without using header files at all.

我想知道是否有可能不使用头文件而编写C/ c++程序。

#include <iostream.h> //I want this same code to work without including this line
#include <conio.h>    //I want this same code to work without including this line

int main ()
{
  clrscr();
  char str [80];
  int num;
  cout<<"Enter the string : "<<str;
  cin>>str;
  cout<<"Enter the number : "<<num;
  cin>>num;
  getch();  
  return 0;
}

I learned that in C we can use scanf() function without using stdio.h

我了解到在C语言中我们可以使用scanf()函数而不用stdi .h

Example:

例子:

#include <stdio.h>

int main ()
{
  char str [80];
  scanf ("%s",str);  
  return 0;
}

The above code can be written as

上面的代码可以写成

extern int scanf(const char *format, ...);

int main ()
{
  char str [80];
  scanf ("%s",str);  
  return 0;
}

Here by calling extern int scanf(const char *format, ...);, scanf() will work seamlessly.

在这里，通过调用extern int scanf(const char *format，…);，scanf()将无缝地工作。

I am a trainer, my students asked me about this weird doubt and its my reason. I need to how it can be achieved with some code, just like extern int scanf(const char *format, ...); for replacing stdio.h

我是一名培训师，我的学生问我这个奇怪的疑问和原因。我需要了解如何用一些代码来实现它，就像extern int scanf(const char *format，…);为替换文件

4 个解决方案

#1

I am not sure I understand the reasons behind your question but there is a (very ugly) way.

我不确定我是否理解你问题背后的原因，但有一个(非常丑陋的)方法。

Simply use your preprocessor (and not the compiler) with the right options (which depend on your environment) and it will generate a header-free equivalent CPP file which can be compiled.

只需使用您的预处理器(而不是编译器)和正确的选项(这取决于您的环境)，它将生成一个可以编译的无头等效CPP文件。

Doing the same thing manually is just very prone to errors... and in my opinion completely useless.

手工做同样的事情很容易出错……在我看来完全没用。

Below is an example based on provided code in the question.

下面是一个基于问题中提供的代码的示例。

#include <stdio.h>

int main ()
{
    char str [80];
      scanf ("%s",str);
        return 0;
}

Using the command gcc -E main.cpp|grep -v "^#" |grep -v "^$" i extracted the following code (note that lines starting with # and empty lines were removed by my grep commands) :

使用gcc -E main命令。cpp | grep - v”^ # | grep - v“^ $”我提取以下代码(注意行以#开始,空行删除我的grep命令):

extern "C" {
typedef unsigned int size_t;
typedef unsigned char __u_char;
typedef unsigned short int __u_short;
typedef unsigned int __u_int;
typedef unsigned long int __u_long;
typedef signed char __int8_t;
typedef unsigned char __uint8_t;
typedef signed short int __int16_t;
typedef unsigned short int __uint16_t;
typedef signed int __int32_t;
typedef unsigned int __uint32_t;
__extension__ typedef signed long long int __int64_t;
__extension__ typedef unsigned long long int __uint64_t;
__extension__ typedef long long int __quad_t;
__extension__ typedef unsigned long long int __u_quad_t;
__extension__ typedef __u_quad_t __dev_t;
__extension__ typedef unsigned int __uid_t;
__extension__ typedef unsigned int __gid_t;
__extension__ typedef unsigned long int __ino_t;
__extension__ typedef __u_quad_t __ino64_t;
__extension__ typedef unsigned int __mode_t;
__extension__ typedef unsigned int __nlink_t;
__extension__ typedef long int __off_t;
__extension__ typedef __quad_t __off64_t;
__extension__ typedef int __pid_t;
__extension__ typedef struct { int __val[2]; } __fsid_t;
__extension__ typedef long int __clock_t;
__extension__ typedef unsigned long int __rlim_t;
__extension__ typedef __u_quad_t __rlim64_t;
__extension__ typedef unsigned int __id_t;
__extension__ typedef long int __time_t;
__extension__ typedef unsigned int __useconds_t;
__extension__ typedef long int __suseconds_t;
__extension__ typedef int __daddr_t;
__extension__ typedef long int __swblk_t;
__extension__ typedef int __key_t;
__extension__ typedef int __clockid_t;
__extension__ typedef void * __timer_t;
__extension__ typedef long int __blksize_t;
__extension__ typedef long int __blkcnt_t;
__extension__ typedef __quad_t __blkcnt64_t;
__extension__ typedef unsigned long int __fsblkcnt_t;
__extension__ typedef __u_quad_t __fsblkcnt64_t;
__extension__ typedef unsigned long int __fsfilcnt_t;
__extension__ typedef __u_quad_t __fsfilcnt64_t;
__extension__ typedef int __ssize_t;
typedef __off64_t __loff_t;
typedef __quad_t *__qaddr_t;
typedef char *__caddr_t;
__extension__ typedef int __intptr_t;
__extension__ typedef unsigned int __socklen_t;
struct _IO_FILE;
typedef struct _IO_FILE FILE;
typedef struct _IO_FILE __FILE;
typedef struct
{
  int __count;
  union
  {
    unsigned int __wch;
    char __wchb[4];
  } __value;
} __mbstate_t;
typedef struct
{
  __off_t __pos;
  __mbstate_t __state;
} _G_fpos_t;
typedef struct
{
  __off64_t __pos;
  __mbstate_t __state;
} _G_fpos64_t;
typedef int _G_int16_t __attribute__ ((__mode__ (__HI__)));
typedef int _G_int32_t __attribute__ ((__mode__ (__SI__)));
typedef unsigned int _G_uint16_t __attribute__ ((__mode__ (__HI__)));
typedef unsigned int _G_uint32_t __attribute__ ((__mode__ (__SI__)));
typedef __builtin_va_list __gnuc_va_list;
struct _IO_jump_t; struct _IO_FILE;
typedef void _IO_lock_t;
struct _IO_marker {
  struct _IO_marker *_next;
  struct _IO_FILE *_sbuf;
  int _pos;
};
enum __codecvt_result
{
  __codecvt_ok,
  __codecvt_partial,
  __codecvt_error,
  __codecvt_noconv
};
struct _IO_FILE {
  int _flags;
  char* _IO_read_ptr;
  char* _IO_read_end;
  char* _IO_read_base;
  char* _IO_write_base;
  char* _IO_write_ptr;
  char* _IO_write_end;
  char* _IO_buf_base;
  char* _IO_buf_end;
  char *_IO_save_base;
  char *_IO_backup_base;
  char *_IO_save_end;
  struct _IO_marker *_markers;
  struct _IO_FILE *_chain;
  int _fileno;
  int _flags2;
  __off_t _old_offset;
  unsigned short _cur_column;
  signed char _vtable_offset;
  char _shortbuf[1];
  _IO_lock_t *_lock;
  __off64_t _offset;
  void *__pad1;
  void *__pad2;
  void *__pad3;
  void *__pad4;
  size_t __pad5;
  int _mode;
  char _unused2[15 * sizeof (int) - 4 * sizeof (void *) - sizeof (size_t)];
};
struct _IO_FILE_plus;
extern struct _IO_FILE_plus _IO_2_1_stdin_;
extern struct _IO_FILE_plus _IO_2_1_stdout_;
extern struct _IO_FILE_plus _IO_2_1_stderr_;
typedef __ssize_t __io_read_fn (void *__cookie, char *__buf, size_t __nbytes);
typedef __ssize_t __io_write_fn (void *__cookie, __const char *__buf,
     size_t __n);
typedef int __io_seek_fn (void *__cookie, __off64_t *__pos, int __w);
typedef int __io_close_fn (void *__cookie);
typedef __io_read_fn cookie_read_function_t;
typedef __io_write_fn cookie_write_function_t;
typedef __io_seek_fn cookie_seek_function_t;
typedef __io_close_fn cookie_close_function_t;
typedef struct
{
  __io_read_fn *read;
  __io_write_fn *write;
  __io_seek_fn *seek;
  __io_close_fn *close;
} _IO_cookie_io_functions_t;
typedef _IO_cookie_io_functions_t cookie_io_functions_t;
struct _IO_cookie_file;
extern void _IO_cookie_init (struct _IO_cookie_file *__cfile, int __read_write,
        void *__cookie, _IO_cookie_io_functions_t __fns);
extern "C" {
extern int __underflow (_IO_FILE *);
extern int __uflow (_IO_FILE *);
extern int __overflow (_IO_FILE *, int);
extern int _IO_getc (_IO_FILE *__fp);
extern int _IO_putc (int __c, _IO_FILE *__fp);
extern int _IO_feof (_IO_FILE *__fp) throw ();
extern int _IO_ferror (_IO_FILE *__fp) throw ();
extern int _IO_peekc_locked (_IO_FILE *__fp);
extern void _IO_flockfile (_IO_FILE *) throw ();
extern void _IO_funlockfile (_IO_FILE *) throw ();
extern int _IO_ftrylockfile (_IO_FILE *) throw ();
extern int _IO_vfscanf (_IO_FILE * __restrict, const char * __restrict,
   __gnuc_va_list, int *__restrict);
extern int _IO_vfprintf (_IO_FILE *__restrict, const char *__restrict,
    __gnuc_va_list);
extern __ssize_t _IO_padn (_IO_FILE *, int, __ssize_t);
extern size_t _IO_sgetn (_IO_FILE *, void *, size_t);
extern __off64_t _IO_seekoff (_IO_FILE *, __off64_t, int, int);
extern __off64_t _IO_seekpos (_IO_FILE *, __off64_t, int);
extern void _IO_free_backup_area (_IO_FILE *) throw ();
}
typedef __gnuc_va_list va_list;
typedef __off_t off_t;
typedef __off64_t off64_t;
typedef __ssize_t ssize_t;
typedef _G_fpos_t fpos_t;
typedef _G_fpos64_t fpos64_t;
extern struct _IO_FILE *stdin;
extern struct _IO_FILE *stdout;
extern struct _IO_FILE *stderr;
extern int remove (__const char *__filename) throw ();
extern int rename (__const char *__old, __const char *__new) throw ();
extern int renameat (int __oldfd, __const char *__old, int __newfd,
       __const char *__new) throw ();
extern FILE *tmpfile (void) ;
extern FILE *tmpfile64 (void) ;
extern char *tmpnam (char *__s) throw () ;
extern char *tmpnam_r (char *__s) throw () ;
extern char *tempnam (__const char *__dir, __const char *__pfx)
     throw () __attribute__ ((__malloc__)) ;
extern int fclose (FILE *__stream);
extern int fflush (FILE *__stream);
extern int fflush_unlocked (FILE *__stream);
extern int fcloseall (void);
extern FILE *fopen (__const char *__restrict __filename,
      __const char *__restrict __modes) ;
extern FILE *freopen (__const char *__restrict __filename,
        __const char *__restrict __modes,
        FILE *__restrict __stream) ;
extern FILE *fopen64 (__const char *__restrict __filename,
        __const char *__restrict __modes) ;
extern FILE *freopen64 (__const char *__restrict __filename,
   __const char *__restrict __modes,
   FILE *__restrict __stream) ;
extern FILE *fdopen (int __fd, __const char *__modes) throw () ;
extern FILE *fopencookie (void *__restrict __magic_cookie,
     __const char *__restrict __modes,
     _IO_cookie_io_functions_t __io_funcs) throw () ;
extern FILE *fmemopen (void *__s, size_t __len, __const char *__modes)
  throw () ;
extern FILE *open_memstream (char **__bufloc, size_t *__sizeloc) throw () ;
extern void setbuf (FILE *__restrict __stream, char *__restrict __buf) throw ();
extern int setvbuf (FILE *__restrict __stream, char *__restrict __buf,
      int __modes, size_t __n) throw ();
extern void setbuffer (FILE *__restrict __stream, char *__restrict __buf,
         size_t __size) throw ();
extern void setlinebuf (FILE *__stream) throw ();
extern int fprintf (FILE *__restrict __stream,
      __const char *__restrict __format, ...);
extern int printf (__const char *__restrict __format, ...);
extern int sprintf (char *__restrict __s,
      __const char *__restrict __format, ...) throw ();
extern int vfprintf (FILE *__restrict __s, __const char *__restrict __format,
       __gnuc_va_list __arg);
extern int vprintf (__const char *__restrict __format, __gnuc_va_list __arg);
extern int vsprintf (char *__restrict __s, __const char *__restrict __format,
       __gnuc_va_list __arg) throw ();
extern int snprintf (char *__restrict __s, size_t __maxlen,
       __const char *__restrict __format, ...)
     throw () __attribute__ ((__format__ (__printf__, 3, 4)));
extern int vsnprintf (char *__restrict __s, size_t __maxlen,
        __const char *__restrict __format, __gnuc_va_list __arg)
     throw () __attribute__ ((__format__ (__printf__, 3, 0)));
extern int vasprintf (char **__restrict __ptr, __const char *__restrict __f,
        __gnuc_va_list __arg)
     throw () __attribute__ ((__format__ (__printf__, 2, 0))) ;
extern int __asprintf (char **__restrict __ptr,
         __const char *__restrict __fmt, ...)
     throw () __attribute__ ((__format__ (__printf__, 2, 3))) ;
extern int asprintf (char **__restrict __ptr,
       __const char *__restrict __fmt, ...)
     throw () __attribute__ ((__format__ (__printf__, 2, 3))) ;
extern int vdprintf (int __fd, __const char *__restrict __fmt,
       __gnuc_va_list __arg)
     __attribute__ ((__format__ (__printf__, 2, 0)));
extern int dprintf (int __fd, __const char *__restrict __fmt, ...)
     __attribute__ ((__format__ (__printf__, 2, 3)));
extern int fscanf (FILE *__restrict __stream,
     __const char *__restrict __format, ...) ;
extern int scanf (__const char *__restrict __format, ...) ;
extern int sscanf (__const char *__restrict __s,
     __const char *__restrict __format, ...) throw ();
extern int vfscanf (FILE *__restrict __s, __const char *__restrict __format,
      __gnuc_va_list __arg)
     __attribute__ ((__format__ (__scanf__, 2, 0))) ;
extern int vscanf (__const char *__restrict __format, __gnuc_va_list __arg)
     __attribute__ ((__format__ (__scanf__, 1, 0))) ;
extern int vsscanf (__const char *__restrict __s,
      __const char *__restrict __format, __gnuc_va_list __arg)
     throw () __attribute__ ((__format__ (__scanf__, 2, 0)));
extern int fgetc (FILE *__stream);
extern int getc (FILE *__stream);
extern int getchar (void);
extern int getc_unlocked (FILE *__stream);
extern int getchar_unlocked (void);
extern int fgetc_unlocked (FILE *__stream);
extern int fputc (int __c, FILE *__stream);
extern int putc (int __c, FILE *__stream);
extern int putchar (int __c);
extern int fputc_unlocked (int __c, FILE *__stream);
extern int putc_unlocked (int __c, FILE *__stream);
extern int putchar_unlocked (int __c);
extern int getw (FILE *__stream);
extern int putw (int __w, FILE *__stream);
extern char *fgets (char *__restrict __s, int __n, FILE *__restrict __stream)
     ;
extern char *gets (char *__s) ;
extern char *fgets_unlocked (char *__restrict __s, int __n,
        FILE *__restrict __stream) ;
extern __ssize_t __getdelim (char **__restrict __lineptr,
          size_t *__restrict __n, int __delimiter,
          FILE *__restrict __stream) ;
extern __ssize_t getdelim (char **__restrict __lineptr,
        size_t *__restrict __n, int __delimiter,
        FILE *__restrict __stream) ;
extern __ssize_t getline (char **__restrict __lineptr,
       size_t *__restrict __n,
       FILE *__restrict __stream) ;
extern int fputs (__const char *__restrict __s, FILE *__restrict __stream);
extern int puts (__const char *__s);
extern int ungetc (int __c, FILE *__stream);
extern size_t fread (void *__restrict __ptr, size_t __size,
       size_t __n, FILE *__restrict __stream) ;
extern size_t fwrite (__const void *__restrict __ptr, size_t __size,
        size_t __n, FILE *__restrict __s);
extern int fputs_unlocked (__const char *__restrict __s,
      FILE *__restrict __stream);
extern size_t fread_unlocked (void *__restrict __ptr, size_t __size,
         size_t __n, FILE *__restrict __stream) ;
extern size_t fwrite_unlocked (__const void *__restrict __ptr, size_t __size,
          size_t __n, FILE *__restrict __stream);
extern int fseek (FILE *__stream, long int __off, int __whence);
extern long int ftell (FILE *__stream) ;
extern void rewind (FILE *__stream);
extern int fseeko (FILE *__stream, __off_t __off, int __whence);
extern __off_t ftello (FILE *__stream) ;
extern int fgetpos (FILE *__restrict __stream, fpos_t *__restrict __pos);
extern int fsetpos (FILE *__stream, __const fpos_t *__pos);
extern int fseeko64 (FILE *__stream, __off64_t __off, int __whence);
extern __off64_t ftello64 (FILE *__stream) ;
extern int fgetpos64 (FILE *__restrict __stream, fpos64_t *__restrict __pos);
extern int fsetpos64 (FILE *__stream, __const fpos64_t *__pos);
extern void clearerr (FILE *__stream) throw ();
extern int feof (FILE *__stream) throw () ;
extern int ferror (FILE *__stream) throw () ;
extern void clearerr_unlocked (FILE *__stream) throw ();
extern int feof_unlocked (FILE *__stream) throw () ;
extern int ferror_unlocked (FILE *__stream) throw () ;
extern void perror (__const char *__s);
extern int sys_nerr;
extern __const char *__const sys_errlist[];
extern int _sys_nerr;
extern __const char *__const _sys_errlist[];
extern int fileno (FILE *__stream) throw () ;
extern int fileno_unlocked (FILE *__stream) throw () ;
extern FILE *popen (__const char *__command, __const char *__modes) ;
extern int pclose (FILE *__stream);
extern char *ctermid (char *__s) throw ();
extern char *cuserid (char *__s);
struct obstack;
extern int obstack_printf (struct obstack *__restrict __obstack,
      __const char *__restrict __format, ...)
     throw () __attribute__ ((__format__ (__printf__, 2, 3)));
extern int obstack_vprintf (struct obstack *__restrict __obstack,
       __const char *__restrict __format,
       __gnuc_va_list __args)
     throw () __attribute__ ((__format__ (__printf__, 2, 0)));
extern void flockfile (FILE *__stream) throw ();
extern int ftrylockfile (FILE *__stream) throw () ;
extern void funlockfile (FILE *__stream) throw ();
}
int main ()
{
    char str [80];
      scanf ("%s",str);
        return 0;
}

Yes, it does hurts the eye a bit...

是的，确实有点疼……

#2

Yes. Remember, that #include reads the file and puts it literally in the place of this compiler directive. So you can simply manually copy contents of stdio.h and other headers to your cpp file and append your code at the bottom.

是的。记住，#include读取文件并将其按字面意义放在编译器指令的位置。所以你可以手工复制stdio的内容。h和其他的头文件到你的cpp文件和附加你的代码在底部。

Not recommended, though ;)

不推荐);

---

Edit: In response to comments:

编辑:回应评论:

Here you go: http://pastebin.com/QG7MM3a7

给你:http://pastebin.com/QG7MM3a7

#3

The C11 standard, §7.1.4/2 guarantees:

C11标准,§7.1.4/2担保:

Provided that a library function can be declared without reference to any type defined in a header, it is also permissible to declare the function and use it without including its associated header.

如果可以声明库函数而不引用头中定义的任何类型，那么也允许声明函数并使用它而不包括它的关联头。

Your program is thus valid input to anything that advertises itself as compatible with the C programming language.

因此，您的程序对任何宣称与C编程语言兼容的内容都是有效的输入。

It is true that any such system is also guaranteed to declare printf inside stdio.h, so it would be much easier (and more obvious) to use #include.

确实，任何这样的系统都保证在stdio中声明printf。h，所以使用#include要容易得多(也更明显)。

But including a header also has side effects that may be undesirable: in C, it causes the identifiers declared by the header to become reserved as macro names. (So you can do #define printf foo only if you do not include <stdio.h>.) In C++, including any standard header causes all identifiers which are keywords, or are defined in any standard header, to become reserved as macro names. (In C, I cannot find in the standard what forbids you from something like #define while 42, but there is probably something equivalent.)

但是，包含header也有可能不受欢迎的副作用:在C语言中，它导致header声明的标识符被保留为宏名。(因此，只有在不包含 的情况下，才能执行#define printf foo。)在c++中，包括任何标准头，都将所有关键字标识符(或在任何标准头中定义的标识符)保留为宏名。(在C语言中，我在标准中找不到什么禁止您使用#define while 42之类的东西，但可能有一些相同的东西。)

So, if you want permission to go crazy redefining keywords to other things, feel free to write programs that way. But, nobody will be willing to help you, except perhaps compiler authors who care deeply about compliance, but we tend to prefer complaints to be stated in precise legalese. Without being able to do that, your situation would become that nobody will help or work with you.

所以，如果你想要得到允许去疯狂地重新定义关键字到其他东西，请随意编写程序。但是，没有人愿意帮助您，除了可能是非常关心遵从性的编译器作者之外，但是我们倾向于使用精确的法律术语来表达抱怨。如果不能做到这一点，你的处境将会变成没有人会帮助你或和你一起工作。

#4

Short answer: Yes

简短的回答:是的

Long answer: Yes, but you probably won't gain much because you will end up duplicating most of the work yourself.

长话短说:是的，但是你可能不会得到什么，因为你最终会自己复制大部分的工作。

Header files, like stdio.h, usually provide lots of function declarations. Note that declarations are not definitions. Declarations merely tell the compiler to trust that the function exists (and allow you to call it), while definitions provide the code for the function itself.

头文件,就像它。h，通常提供很多函数声明。注意声明不是定义。声明只是告诉编译器相信函数存在(并允许您调用它)，而定义则为函数本身提供代码。

You are providing a declaration for scanf(), so the compiler allows you to call it. However, the stdio.h header already provides a declaration for scanf, so you don't really gain a whole lot. Furthermore, the only reason that this just works is because the definition for scanf() happens to already exist in your executable --- most likely because it is a library function and your compiler automatically includes that library. If it had not included the library that contains scanf(), the linker (which runs after the compiler) would have complained and given you an error along the lines of "undefined reference to scanf()...".

您正在为scanf()提供一个声明，因此编译器允许您调用它。然而,stdio。scanf h头已经提供了声明,所以你真的不增加很多。此外,这只是工作的唯一原因是因为定义scanf()发生在已经存在在你的可执行文件- - -最有可能的,因为它是一个库函数,编译器自动包括图书馆。如果它没有包含包含scanf()的库，链接器(在编译器之后运行)就会向您投诉，并在“scanf()的未定义引用……”行中给您一个错误。

So, you can avoid using the standard headers by providing declarations for all of the library functions you wish to use, but you must be careful that the declarations you provide match up exactly with what is contained in the library (else you may get unresolved symbol/reference errors from the linker). This is in fact the job of most headers --- they act as 'contracts' between different modules of code. In this case, the stdio.h header is a 'contract' for some of the functions provided by the standard libraries: it allows you to call them by providing declarations, but furthermore, it implicitly claims that the definitions for those functions exist somewhere.

所以,你可以避免使用标准头通过为所有的库函数提供声明你想使用,但是你必须小心,您提供的声明完全匹配与库中包含(其他你可能得到未解决符号/引用错误的链接)。这实际上是大多数header的工作——它们在不同的代码模块之间充当“契约”。这里是stdio。h header是标准库提供的一些函数的“契约”:它允许您通过提供声明来调用它们，但它还隐含地声明这些函数的定义存在于某处。

With all that in mind, do you really want to avoid including the headers and having to manually pick and choose which functions you declare (while simultaneously cross-checking to make sure you got the declaration right)?

考虑到所有这些，您真的希望避免包含报头，并必须手动选择声明的函数(同时进行交叉检查以确保声明正确)吗?

Edit: I may have misunderstood the purpose of the question. Yes, you should be able to write nearly any program and use nearly all APIs without actually including a header, but you will have to tediously cross-check all of your declarations to make sure that they are correct. You will also lose out on any inline definitions provided by headers for optimization.

编辑:我可能误解了问题的目的。是的，您应该能够编写几乎任何程序并使用几乎所有的api，而实际上不包括头，但是您将不得不费力地交叉检查所有声明，以确保它们是正确的。您还将失去header为优化提供的任何内联定义。