A1: c++20 variation and report.

4 files changed, 67 insertions, 1 deletions

diff --git a/a1/.gitignore b/a1/.gitignore
new file mode 100644
index 0000000..04e88da
--- /dev/null
+++ b/a1/.gitignore
@@ -0,0 +1,2 @@
+hello
+hello-cpp20
\ No newline at end of file
diff --git a/a1/Makefile b/a1/Makefile
index af4aa77..8bab294 100644
--- a/a1/Makefile
+++ b/a1/Makefile
@@ -1,3 +1,10 @@
-all:
+all: hello hello-cpp20
+
+hello: hello.cc
 	g++ -std=c++20 -fmodules-ts -x c++-system-header iostream
 	g++ -std=c++20 -fmodules-ts hello.cc -o hello
+
+hello-cpp20: hello-cpp20.cc
+	g++ -std=c++20 -fmodules-ts -x c++-system-header iostream
+	g++ -std=c++20 -fmodules-ts -x c++-system-header string
+	g++ -std=c++20 -fmodules-ts hello-cpp20.cc -o hello-cpp20
diff --git a/a1/exercise.tex b/a1/exercise.tex
new file mode 100644
index 0000000..b02f83f
--- /dev/null
+++ b/a1/exercise.tex
@@ -0,0 +1,36 @@
+\title{A1: Tool Chain}
+\input{preamble.tex}
+
+This assignment consists of two small programs; \texttt{hello.cc}
+and \texttt{hello-cpp20.cc}.
+Both use \texttt{import <module>} rather the \texttt{\#include <module>}
+which on my tool-chain (gcc on linux) requires some pre-generation in
+order to work.
+A \texttt{Makefile} is provided which handles all the necessary
+pre-generation as well as the actual compilation of the programs.
+
+\section*{Exercise 1}
+The \texttt{hello.cc} simply prints a \texttt{const char*} literal
+string to the console using the \texttt{std::cout} output stream.
+
+\section*{Exercise 2}
+The \texttt{hello-cpp2.cc} wraps the printing in a templated function,
+utilizing a \texttt{concept} ``Printable'' to make sure that the stream
+operator is implemented on the supplied type for the \texttt{std::cout}
+stream.
+Examples of calling the function is supplied; one using a \texttt{const
+  char*} literal string, one using a \texttt{std::string} literal, one
+using an \texttt{int}, and finally one using a custom type which fails
+compilation because it doesn't provide a stream operator implementaion
+for \texttt{std::ostream}.
+
+Initially I had the argument for the \texttt{printIt} function being
+just a reference, which failed compilation because of the
+\texttt{std::string} litteral being a temporary.
+Adding \texttt{const} fixed the issue.
+
+I originally had the idea to somehow use \texttt{std::format} for the
+second part of the exercise, but since this is not yet supported by my
+compiler I had to change plans.
+
+\end{document}
diff --git a/a1/hello-cpp20.cc b/a1/hello-cpp20.cc
new file mode 100644
index 0000000..76b2bbd
--- /dev/null
+++ b/a1/hello-cpp20.cc
@@ -0,0 +1,21 @@
+import <iostream>;
+import <string>;
+
+template<typename T>
+concept Printable = requires(T a) { std::cout << a; };
+
+void printIt(const Printable auto& p)
+{
+	std::cout << p;
+}
+
+struct MyType {};
+
+int main()
+{
+	using namespace std::string_literals;
+	printIt("Hello Modern World!\n"); // ok, const char* string is printable
+	printIt("Hello Modern World!\n"s); // ok, std::string literal is printable
+	printIt(42); // ok, int is printable
+	// printIt(MyType{}); // error: doesn't adhere to Printable concept
+}