A slightly strange question, however, if I remember correctly, C++ source code doesn't require a file system to store its files.
Having a compiler that scans handwritten papers via a camera would be a conforming implementation. Although practically not making that much sense.
However C++20 now adds source location with file_name. Does this now imply that source code should always be stored in a file?
You can compile (and link) C++ completely within a pipe, putting your compiler in the middle, e.g.
generate_source | g++ -o- -xc++ - | do_something_with_the_binary
and it's been like that for decades. See also:
The introduction of std::source_location in C++20 doesn't change this state of affairs. It's just that some code will not have a well-defined source location (or it may be well-defined, but not very meaningful). Actually, I'd say that the insistence on defining std::source_location using files is a bit myopic... although in fairness, it's just a macro-less equivalent of __FILE__ and __LINE__ which already exist in C++ (and C).
@HBv6 notes that if you print the value of __FILE__ when compiling using GCC from the standard input stream:
echo -e '#include <iostream>\n int main(){std::cout << __FILE__ ;}' | g++ -xc++ -
running the resulting executable prints <stdin>.
@Morwenn notes that this code:
#include <https://raw.githubusercontent.com/Morwenn/poplar-heap/master/poplar.h>
// Type your code here, or load an example.
void poplar_sort(int* data, size_t size) {
poplar::make_heap(data, data + size);
poplar::sort_heap(data, data + size);
}
works on GodBolt (but won't work on your machine - no popular compiler supports this.)
The question of whether C++ program sources need to come from files is not answered clearly in the language standard. Looking at a draft of the C++17 standard (n4713), section 5.1 [lex.separate] reads:
- The text of the program is kept in units called source files in this document. A source file together with all the headers (20.5.1.2) and source files included (19.2) via the preprocessing directive #include, less any source lines skipped by any of the conditional inclusion (19.1) preprocessing directives, is called a translation unit.
So, the source code is not necessarily kept in a file per se, but in a "unit called a source file". But then, where do the includes come from? One would assume they come from named files on the filesystem... but that too is not mandated.
At any rate, std::source_location does not seem to change this wording in C++20 or to affect its interpretation (AFAICT).
Even before C++20, the standard has had:
__FILE__The presumed name of the current source file (a character string literal).
The definition is the same for source_location::file_name.
As such, there has not been a change in regard to support for file system-less implementations in C++20.
The standard doesn't exactly define what "source file" means, so whether it refers to a file system may be up to interpretation. Presumably, it could be conforming for an implementation to produce "the handwritten note that you gave to me just then" if that indeed identifies the "source file" in that implementation of the language.
In conclusion: Yeah, sources are referred to as "files" by the standard, but what a "file" is and whether a file system is involved is unspecified.
