„#include“ eine Textdatei in einem C-Programm als Zeichen[]

Question 1

Gibt es eine Möglichkeit, eine vollständige Textdatei zur Kompilierzeit als Zeichenfolge in ein C-Programm einzufügen?

etwas wie:

Datei.txt:
```
This is
a little
text file
```

Haupt c:

#include <stdio.h>
int main(void) {
   #blackmagicinclude("file.txt", content)
   /*
   equiv: char[] content = "This is\na little\ntext file";
   */
   printf("%s", content);
}

Erhalten eines kleinen Programms, das auf stdout “Dies ist eine kleine Textdatei” ausgibt

Im Moment habe ich ein hackiges Python-Skript verwendet, aber es ist hässlich und auf nur einen Variablennamen beschränkt. Können Sie mir eine andere Möglichkeit nennen?

Question 2

Ich würde vorschlagen, (unix util) zu verwendenxxd dafür. du kannst es so verwenden

$ echo hello world > a
$ xxd -i a

Ausgänge:

unsigned char a[] = {
  0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x20, 0x77, 0x6f, 0x72, 0x6c, 0x64, 0x0a
};
unsigned int a_len = 12;

Question 3

Die Frage bezog sich auf C, aber falls jemand versucht, es mit C ++ 11 zu tun, kann dies dank des neuen mit nur geringfügigen Änderungen an der enthaltenen Textdatei erfolgen rohe Zeichenfolgenliterale:

In C++ tun Sie dies:

const char *s =
#include "test.txt"
;

In der Textdatei tun Sie dies:

R"(Line 1
Line 2
Line 3
Line 4
Line 5
Line 6)"

Es muss also nur ein Präfix am Anfang der Datei und ein Suffix am Ende stehen. Dazwischen können Sie machen, was Sie wollen, es ist kein spezielles Escapezeichen nötig, solange Sie die Zeichenfolge nicht benötigen )". Aber auch das kann funktionieren, wenn Sie Ihr eigenes benutzerdefiniertes Trennzeichen angeben:

R"=====(Line 1
Line 2
Line 3
Now you can use "( and )" in the text file, too.
Line 5
Line 6)====="

Question 4

Ich mag Kayahrs Antwort. Wenn Sie die Eingabedateien nicht berühren möchten jedoch, und wenn Sie verwenden CMake, können Sie die Trennzeichenfolgen in der Datei hinzufügen. Der folgende CMake-Code kopiert beispielsweise die Eingabedateien und umschließt ihren Inhalt entsprechend:

function(make_includable input_file output_file)
    file(READ ${input_file} content)
    set(delim "for_c++_include")
    set(content "R\"${delim}(\n${content})${delim}\"")
    file(WRITE ${output_file} "${content}")
endfunction(make_includable)

# Use like
make_includable(external/shaders/cool.frag generated/cool.frag)

Dann in c++ wie folgt einfügen:

constexpr char *test =
#include "generated/cool.frag"
;

Question 5

Sie haben zwei Möglichkeiten:

Verwenden Sie Compiler/Linker-Erweiterungen, um eine Datei in eine Binärdatei zu konvertieren, wobei die richtigen Symbole auf den Anfang und das Ende der Binärdaten zeigen. Siehe diese Antwort: Binärdatei mit GNU-ld-Linker-Skript einschließen.
Konvertieren Sie Ihre Datei in eine Folge von Zeichenkonstanten, die ein Array initialisieren können. Beachten Sie, dass Sie nicht einfach “” ausführen und sich über mehrere Zeilen erstrecken können. Sie benötigen ein Zeilenfortsetzungszeichen (\), Flucht " Charaktere und andere, damit das funktioniert. Einfacher ist es, einfach ein kleines Programm zu schreiben, um die Bytes in eine Sequenz wie z '\xFF', '\xAB', ...., '\0' (Oder verwenden Sie das Unix-Tool xxd beschrieben durch eine andere Antwort, wenn Sie es zur Verfügung haben!):

Code:

#include <stdio.h>

int main() {
    int c;
    while((c = fgetc(stdin)) != EOF) {
        printf("'\\x%X',", (unsigned)c);
    }
    printf("'\\0'"); // put terminating zero
}

(nicht getestet). Dann mach:

char my_file[] = {
#include "data.h"
};

Wo data.h generiert wird

cat file.bin | ./bin2c > data.h

Question 6

ok, inspiriert von Daemins Post habe ich das folgende einfache Beispiel getestet:

a.Daten:

"this is test\n file\n"

test.c:

int main(void)
{
    char *test = 
#include "a.data"
    ;
    return 0;
}

gcc -E test.c Ausgabe:

# 1 "test.c"
# 1 "<built-in>"
# 1 "<command line>"
# 1 "test.c"

int main(void)
{
    char *test =
# 1 "a.data" 1
"this is test\n file\n"
# 6 "test.c" 2
    ;
    return 0;
}

Es funktioniert also, erfordert aber Daten, die in Anführungszeichen gesetzt sind.

Question 7

Sie können dies mit tun objcopy:

objcopy --input binary --output elf64-x86-64 myfile.txt myfile.o

Jetzt haben Sie eine Objektdatei, die Sie mit Ihrer ausführbaren Datei verknüpfen können, die Symbole für den Anfang, das Ende und die Größe des Inhalts enthält myfile.txt.

Question 8

Wenn Sie bereit sind, auf einige schmutzige Tricks zurückzugreifen, können Sie mit rohen Zeichenfolgenliteralen und kreativ werden #include für bestimmte Dateitypen.

Angenommen, ich möchte einige SQL-Skripts für SQLite in mein Projekt einbinden und Syntaxhervorhebung erhalten, möchte aber keine spezielle Build-Infrastruktur. Ich kann diese Datei haben test.sql das ist gültiges SQL für SQLite wo -- beginnt einen Kommentar:

--x, R"(--
SELECT * from TestTable
WHERE field = 5
--)"

Und dann kann ich in meinem C++-Code haben:

int main()
{
    auto x = 0;
    const char* mysql = (
#include "test.sql"
    );

    cout << mysql << endl;
}

Die Ausgabe ist:

--
SELECT * from TestTable
WHERE field = 5
--

Oder um Python-Code aus einer Datei einzufügen test.py was ein gültiges Python-Skript ist (weil # startet einen Kommentar in Python und pass ist ein no-op):

#define pass R"(
pass
def myfunc():
    print("Some Python code")

myfunc()
#undef pass
#define pass )"
pass

Und dann im C++-Code:

int main()
{
    const char* mypython = (
#include "test.py"
    );

    cout << mypython << endl;
}

Was wird ausgeben:

pass
def myfunc():
    print("Some Python code")

myfunc()
#undef pass
#define pass

Es sollte möglich sein, ähnliche Tricks für verschiedene andere Arten von Code zu spielen, die Sie vielleicht als Zeichenfolge einschließen möchten. Ob es eine gute Idee ist, bin ich mir nicht sicher. Es ist ein netter Hack, aber wahrscheinlich nichts, was Sie in echtem Produktionscode wollen würden. Könnte aber für ein Wochenend-Hack-Projekt in Ordnung sein.