/** Copyright (c) Grant Rostig, grantrostig.com 2023. Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt)

NOT PRODUCTION QUALITY CODE, just shows learning/teaching example, not real programming, don't copy this style, just playing around

Reminder of usefull resources:

https://coliru.stacked-crooked.com/

https://godbolt.org/

https://cppinsights.io/

https://Wandbox.org

https://cpp.sh/

https://quick-bench.com/

https://arnemertz.github.io/online-compilers/

[[maybe_unused]] int * my_new_var8 = ::new (22,int);

Language Versions: clan++ -std=c++2b, g++ -std=c++23 or =gnu++23

STD Libraries: Gcc: libstdc++; Clang: libc++; Microsoft: msvc/ms stl // TODO??: how do we link with different libraries than the default using gcc or clang (the exact command line text)?

g++ -Werror -Weffc++ -Wextra -Wall -Wconversion -Wshadow -Wpedantic -Wold-style-cast -Wsign-promo -Wzero-as-null-pointer-constant -Wsuggest-override -Wnon-virtual-dtor \

-Wcast-align -Woverloaded-virtual -Wunused -pedantic -Wsign-conversion -Wmisleading-indentation -Wnull-dereference -Wdouble-promotion -Wformat=2 -Wimplicit-fallthrough \

-Wuseless-cast -Wsuggest-final-types -Wsuggest-final-methods -Wduplicated-cond -Wduplicated-branches -Wlogical-op -std=gnuc++23 \

main.cpp <OTHER>.cpp -o <A.OUT>

SYMBOL MEANING // for debugging purposes

TODO: the principal programmer needs todo.

TODO?: the principal programmer is not sure about something, that should be addressed.

TODO?:X the X programmer is not sure about something, that should be addressed.

TODO??: is a question for verbal discussion at CppMSG.com meetup meetings.

define NDEBUG if asserts are NOT to be checked. Put in *.h file not *.CPP

#define NDEBUG

define GR_DEBUG if we/programmer is Debugging. Put in *.h file not *.CPP

#define GR_DEBUG

#ifdef GR_DEBUG

#endif GR_DEBUG

*/

#include "global_entities.hpp"

#include <gsl/gsl> // sudo dnf install guidelines-support-library-devel

//#include <bits/stdc++.h>

#include <cassert>

#include <chrono>

#include <climits>

#include <csignal>

#include <iostream>

#include <syncstream>

#include <numeric>

#include <optional>

#include <ranges>

#include <source_location>

#include <stacktrace>

#include <stop_token>

#include <string>

#include <type_traits>

#include <utility>

#include <vector>

using std::cin; using std::cout; using std::cerr; using std::clog; using std::endl; using std::string; // using namespace std;

using namespace std::string_literals;

using namespace std::chrono_literals;

namespace Detail { // NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN

} // End Namespace NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN

// ++++++++++++++++ EXAMPLEs begin ++++++++++++++++++++++++++++++++++++++++++++++++++++++++

namespace ExampleP08 { // NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN

/** Using consteval to make constexpr execute at compile-time C++20.

The downside of consteval functions is that such functions can’t evaluate at runtime, making them less flexible than constexpr

functions, which can do either. Therefore, it would still be useful to have a convenient way to force constexpr functions to

evaluate at compile-time (even when the return value is being used where a constant expression is not required), so that we could

have compile-time evaluation when possible, and runtime evaluation when we can’t.

Consteval functions provides a way to make this happen, using a neat helper function:

Uses abbreviated function template (C++20) and `auto` return type to make this function work with any type of value

*Note: not sure what AI or URL this was found on.

We cover auto return types in lesson 10.9 -- Type deduction for functions.

We cover abbreviated function templates (auto parameters) in lesson 11.8 -- Function templates with multiple template types.

*/

consteval auto compileTime (auto value) {

static_assert(std::is_constant_evaluated());

return value;

}

constexpr int greater(int x, int y) {

static_assert(std::is_constant_evaluated());

return (x > y ? x : y);

}

void test1 () { std::cout<< "START ExampleP08 test1. ++++++++++++++++++++++++"<<std::endl;

std::cout << greater(5, 6) << '\n'; // may or may not execute at compile-time

std::cout << compileTime(greater(5, 6)) << '\n'; // will execute at compile-time

int x { 5 };

std::cout << greater(x, 6) << '\n'; // we can still call the constexpr version at runtime if we wish

std::cout<< "END ExampleP08 test1. ++++++++++++++++++++++++"<<std::endl;

} } // END namespace NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN

namespace ExampleNM1 { // NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN

// Constexpr/consteval function parameters are not constexpr (but can be used as arguments to other constexpr functions)

constexpr int goo(int c) {

static_assert(std::is_constant_evaluated());

return c; }

//constexpr std::pair<int,bool> foo(int b) {

constexpr int foo(int b) {

//static_assert(std::is_constant_evaluated());

//assert(std::is_constant_evaluated());

//constexpr int b2 { b }; // compile error: b is not a constant expression within foo()

return goo(b); // okay: b can still be used as argument to constexpr function goo()

//return { goo(b),std::is_constant_evaluated() };

}

void test1 () { std::cout<< "START ExampleNM1 test1. ++++++++++++++++++++++++"<<std::endl;

constexpr int a { 5 };

int b { rand() };

//constexpr auto bar1{ foo(a) };

//auto bar3 = foo(b);

//std::cout << "=" << foo << endl; // okay: constant expression a can be used as argument to constexpr function foo()

//std::cout << "foo(a)=" << bar1.first << "," << bar1.second << endl; // okay: constant expression a can be used as argument to constexpr function foo()

//std::cout << "foo(b)=" << bar3.first << "," << bar3.second << endl; // okay: constant expression a can be used as argument to constexpr function foo()

std::cout<< "END ExampleNM1 test1. ++++++++++++++++++++++++"<<std::endl;

} } // END namespace NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN

namespace ExampleJonsTake { // NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN

constexpr auto factorial(int val) {

if (val == 0) return 1;

return val * factorial( val - 1);

}

constexpr auto factorial2(int val) {

if (val == 0) return 1;

return val * factorial( val - 1);

}

constexpr auto factorial3(int i) {

int f{1};

for (int j{2}; j <= i; ++j) { f *= j; }

return f;

}

// vishal

constexpr auto factorial4(int val){

auto result{ 1 };

std::vector<int> v{val+1};

v[0] = 1;

std::iota(v.begin(), v.end(), 1);

//for (int i{1}; i< (val +1); ++i)

for (auto i : std::ranges::iota_view{ 1, val +1})

result *= i;

return result;

}

template <std::size_t...Is>

constexpr auto factorial4_impl(std::index_sequence<Is...>) {

return (1 * ... * (Is + 1));

}

template <std::size_t I>

constexpr auto factorial4() {

return factorial4_impl(std::make_index_sequence<I>());

}

constexpr auto call_factorial(int val) {

auto ice{std::is_constant_evaluated()? 1: -1};

//int r {rand()};

std::vector<int> v{1,323,33};

v.push_back(val);

v.push_back(ice*val);

//v.push_back(rand());

return factorial(val) * ice * v[1];

}

void test1 () { std::cout<< "START ExampleJonsTake test1. ++++++++++++++++++++++++"<<std::endl;

//auto myValue{call_factorial(6)};

constexpr auto myValue{call_factorial(6)};

//std::array<int, call_factorial(6)> myValues;

//std::cout << sizeof(myValues) << "\n";

std::cout << "myValue: " << myValue << "\n";

static_assert(factorial3(6) == 720);

static_assert(factorial3(1) == 1);

static_assert(factorial4<1>() == 1);

static_assert(factorial4<6>() == 720);

static_assert(factorial4<10>() == 3628800);

std::cout<< "END ExampleJonsTake test1. ++++++++++++++++++++++++"<<std::endl;

} } // END namespace NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN

namespace ExampleJon202505 { // NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN

void input_thread_internal_f (std::stop_token const &st ) {

}

void input_thread_f (std::stop_token const &my_stop_token, std::stop_source my_stop_source ) {

std::string my_string{};

cin >> my_string;

std::osyncstream(cout) << my_string <<"."<< endl; // TODO??: Is there an isyncstream

if ( "q"s == my_string) {

my_stop_source.request_stop();

}

}

#define MY_NUM 43;

const int a{43};

constexpr int b{43};

//inline constexpr int c{43};

// constexpr is a suggestion, need not be done by the compiler.

//constexpr int f( int const i) { // this const only promises to not change within.

consteval int f( int const i) { // this const only promises to not change within.

int const a{i};

int constexpr b{2}; // known at compile at time and const.

std::array<int,b> my_array {2,3}; (void)my_array;

return i+99;

}

constexpr int g( int const i) {

//int const a{ f(i) };

int const b{ f(2) };

//int constinit b1{ f(2) };

int constexpr c{ f(2) }; // known at compile at time and const.

//int constexpr d{ f(i) };

int const x {33};

int constexpr e{ f( float {33} ) };

std::array<int,c> my_array {2,3}; (void)my_array;

return i+99;

}

void test1 () {

for ( int i{0}; i<5 ;++i)

// f(i);

;

}

} // END namespace NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN

namespace ExampleP10 { // NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN

/* Constexpr/consteval function parameters are not constexpr (but can be used as arguments to other constexpr functions)

OBVIOUS: The parameters of a constexpr function are not constexpr (and thus cannot be used in constant expressions). Such parameters can be

declared as const (in which case they are treated as runtime constants), but not constexpr. This is because a constexpr function can

be evaluated at runtime (which wouldn’t be possible if the parameters were compile-time constants).

However, an exception is made in one case: a constexpr function can pass those parameters as arguments to another constexpr function, and that subsequent

constexpr function can be resolved at compile-time. This allows constexpr functions to still be resolved at compile-time when they

call other constexpr functions (including themselves recursively).

Perhaps surprisingly, the parameters of a consteval function are

not considered to be constexpr within the function either (even though consteval functions can only be evaluated at compile-time).

This decision was made for the sake of consistency.

*/

constexpr int goo(int c) {

//static_assert(std::is_constant_evaluated());

//if (std::is_constant_evaluated()) cout << "WHAT\n";

//else cout << "Who\n.";

return c;

}

constexpr int foo(int b) {

//static_assert(std::is_constant_evaluated());

//if ( std::is_constant_evaluated() ) cout << "WHAT\n";

// constexpr int b2 { b }; // compile error: b is not a constant expression within foo()

return goo(b); // okay: b can still be used as argument to constexpr function goo()

}

//constinit int e { 5 };

void test1 () { std::cout<< "START ExampleP10 test1. ++++++++++++++++++++++++"<<std::endl;

constexpr int a { 5 };

std::cout << foo(a) << endl; // okay: constant expression a can be used as argument to constexpr function foo()

// const int c { 5 };

// static constinit int d { 5 }; // B constinit int f { 5 };

// int b { rand() };

// std::cout << foo(b) << endl; //

// std::cout << foo(c) << endl; //

// std::cout << foo(3) << endl; //

std::cout<< "END ExampleP10 test1. ++++++++++++++++++++++++"<<std::endl;

} } // END namespace NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN

namespace ExampleP12 { // NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN

/* Can a constexpr function call a non-constexpr function?

The answer is yes, but only when the constexpr function is being evaluated in a non-constant context. A non-constexpr function may not

be called when a constexpr function is evaluating in a constant context (because then the constexpr function wouldn’t be able to

produce a compile-time constant value).

*/

constexpr int someConstexprFcn(){

return 1212;

}

int someNonConstexprFcn(){

return 121212;

}

constexpr int someFunction() {

if (std::is_constant_evaluated()) // if compile-time evaluation

return someConstexprFcn(); // calculate some value at compile time

else // runtime evaluation

return someNonConstexprFcn(); // calculate some value at runtime

}

constexpr int someFunction(bool b) {

if (b)

return someConstexprFcn();

else

return someNonConstexprFcn();

}

void test1 () { std::cout<< "START ExampleP12 test1. ++++++++++++++++++++++++"<<std::endl;

int i12 { someFunction(12) };

int i13 { someFunction(13) };

std::cout<< "END ExampleP12 test1. ++++++++++++++++++++++++"<<std::endl;

} } // END namespace NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN

int main(int argc, char* arv[]) { string my_arv{*arv}; cout << "~~~ argc, argv:"<<argc<<","<<my_arv<<"."<<endl; cin.exceptions( std::istream::failbit);

Detail::crash_signals_register();

//if (not std::is_constant_evaluated()) cout << "WHAT\n"; // TODO??: can we output via constexpr? iostreams is not??

//ExampleP08::test1 ();

//ExampleP10::test1 ();

//ExampleP12::test1 ();

ExampleJonsTake::test1 ();

cout << "###" << endl;

return EXIT_SUCCESS;

}