C++

Forum

 
a program that print itself

mamali (9)
could any one write a program that print it self ?
Bazzy (6281)
Last edited on
chrisname (7395)
Last edited on
Bazzy (6281)
from Wikipedia
For amusement, programmers sometimes attempt to develop the shortest possible quine in any given programming language.
How to waste your life...
chrisname (7395)
Why is that life-wasting? It may be fun. Lots of programmers do things like that. If I had the skill, I'd join them.
firedraco (6243)
I agree with chrisname...otherwise I'd be 'wasting my life' playing video games >_>
DrChill (574)
If playing video games is a waste of life .... I need a different goal in life hehehee (joking of course)
turbozedd (153)

quine.cpp :
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
#include <cstdio>

int main(int argc, char *argv[])
{
  FILE * pFile;
  int c;
  pFile=fopen ("quine.cpp","r");
  if (pFile==NULL) perror ("Error opening file");
  else
  {
    do {
      c = getc (pFile);
      printf("%c",c);
    } while (c != EOF);
    fclose (pFile);
  }
  return 0;

}
Last edited on
Duthomhas (13206)
That's not a quine. A quine takes no input. It produces its own source. (It doesn't copy it from elsewhere.)
turbozedd (153)
Damn... I knew it was to easy lol

(Really, I knew it was wrong, but I couldn't resist)

PLUS it answers the question as posed -- Yes, I can write a program that prints itself!
Last edited on
Bazzy (6281)
Shortest quine in C++
#include "quine.h"

( "quine.h" contains this:
1
2
3
4
5
6
 
#include <iostream>
int main()
{
    std::cout << "#include\"quine.h\"";
    return 0;
}
)
LOL

@those who will think that this is cheating:
You should anyway #include <iostream> but without the need of printing its contents...
Duthomhas (13206)
I wouldn't count that as a quine...

No quine ever expects you to include reproduce your language's standard library, but it does expect you to reproduce the entire, compilable source.

#include "foo.h" isn't a complete, compilable source.
Last edited on
chrisname (7395)
That's not a quine. A quine prints it's full source code. Take the excellent wikipedia example (which works... but not when I tried to write my own with almost the exact same code >:( ):
$ gcc quine.c -o quine
$ ./quine
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
 
/* A simple quine (self-printing program), in standard C. */
 
/* Note: in designing this quine, we have tried to make the code clear
 * and readable, not concise and obscure as many quines are, so that
 * the general principle can be made clear at the expense of length.
 * In a nutshell: use the same data structure (called "progdata"
 * below) to output the program code (which it represents) and its own
 * textual representation. */
 
#include <stdio.h>
 
void quote(const char *s)
     /* This function takes a character string s and prints the
      * textual representation of s as it might appear formatted
      * in C code. */
{
    int i;
 
    printf("    \"");
    for (i=0; s[i]; ++i) {
        /* Certain characters are quoted. */
        if (s[i] == '\\')
            printf("\\\\");
        else if (s[i] == '"')
            printf("\\\"");
        else if (s[i] == '\n')
            printf("\\n");
        /* Others are just printed as such. */
        else
            printf("%c", s[i]);
        /* Also insert occasional line breaks. */
        if (i % 48 == 47)
            printf("\"\n    \"");
    }
    printf("\"");
}
 
/* What follows is a string representation of the program code,
 * from beginning to end (formatted as per the quote() function
 * above), except that the string _itself_ is coded as two
 * consecutive '@' characters. */
const char progdata[] =
    "/* A simple quine (self-printing program), in st"
    "andard C. */\n\n/* Note: in designing this quine, "
    "we have tried to make the code clear\n * and read"
    "able, not concise and obscure as many quines are"
    ", so that\n * the general principle can be made c"
    "lear at the expense of length.\n * In a nutshell:"
    " use the same data structure (called \"progdata\"\n"
    " * below) to output the program code (which it r"
    "epresents) and its own\n * textual representation"
    ". */\n\n#include <stdio.h>\n\nvoid quote(const char "
    "*s)\n     /* This function takes a character stri"
    "ng s and prints the\n      * textual representati"
    "on of s as it might appear formatted\n      * in "
    "C code. */\n{\n    int i;\n\n    printf(\"    \\\"\");\n "
    "   for (i=0; s[i]; ++i) {\n        /* Certain cha"
    "racters are quoted. */\n        if (s[i] == '\\\\')"
    "\n            printf(\"\\\\\\\\\");\n        else if (s["
    "i] == '\"')\n            printf(\"\\\\\\\"\");\n        e"
    "lse if (s[i] == '\\n')\n            printf(\"\\\\n\");"
    "\n        /* Others are just printed as such. */\n"
    "        else\n            printf(\"%c\", s[i]);\n   "
    "     /* Also insert occasional line breaks. */\n "
    "       if (i % 48 == 47)\n            printf(\"\\\"\\"
    "n    \\\"\");\n    }\n    printf(\"\\\"\");\n}\n\n/* What fo"
    "llows is a string representation of the program "
    "code,\n * from beginning to end (formatted as per"
    " the quote() function\n * above), except that the"
    " string _itself_ is coded as two\n * consecutive "
    "'@' characters. */\nconst char progdata[] =\n@@;\n\n"
    "int main(void)\n     /* The program itself... */\n"
    "{\n    int i;\n\n    /* Print the program code, cha"
    "racter by character. */\n    for (i=0; progdata[i"
    "]; ++i) {\n        if (progdata[i] == '@' && prog"
    "data[i+1] == '@')\n            /* We encounter tw"
    "o '@' signs, so we must print the quoted\n       "
    "      * form of the program code. */\n        {\n "
    "           quote(progdata);    /* Quote all. */\n"
    "            i++;                /* Skip second '"
    "@'. */\n        } else\n            printf(\"%c\", p"
    "rogdata[i]);  /* Print character. */\n    }\n    r"
    "eturn 0;\n}\n";
 
int main(void)
     /* The program itself... */
{
    int i;
 
    /* Print the program code, character by character. */
    for (i=0; progdata[i]; ++i) {
        if (progdata[i] == '@' && progdata[i+1] == '@')
            /* We encounter two '@' signs, so we must print the quoted
             * form of the program code. */
        {
            quote(progdata);    /* Quote all. */
            i++;                /* Skip second '@'. */
        } else
            printf("%c", progdata[i]);  /* Print character. */
    }
    return 0;
}

Last edited on
Topic archived. No new replies allowed.