#include <iostream>
#include <string>
using namespace std;
#include <sto/sto.h>
using namespace sto;
int main() {
string s = "Hello World!";
cout << (s * toupper) << endl;
}
Simple IO
Bar-print
Instead of std::cout printing, in SCC you can use so called bar-print. Below are bar-print statements with equivalent code in comments:
_ x; // cout << x; __ x; // cout << x << endl; __ x, y; // cout << x << " " << y << endl;
On last line " " will not be printed if x or y are strings.
On exit, SCC also checks if last output was unterminated with linefead. If true, it will add a linefead. Let say if last statement was cout << x;, then SCC will add cout << endl; on exit.
OI - Generic ostream_iterator
Standard library includes std::ostream_iterator. Unlike std::cout it accepts only one specific type (specified at construction time) and it is not pre-defined object. So to use it with STL algorithms, you need call its quite verbose constructor.
Let say we have vector<int> V; and set<string> S; and we want to print these. With std::ostream_iterator:
copy(V.begin(), V.end(), ostream_iterator<int> (cout, " ")); copy(S.begin(), S.end(), ostream_iterator<string>(cout, " "));
Include io.h defines oi object - SCC replacement for ostream_iterator, which can work with any type and is pre-defined. With oi, above example will be:
copy(V.begin(), V.end(), oi); copy(S.begin(), S.end(), oi);
Same using range operators, more about these later:
copy(+V, -V, oi); copy(+S, -S, oi);
Also assigning a container to oi is equivalent to doing std::copy, so still shorter:
oi = V; oi = S;
STL Containers input / output
Any STL container can be also printed without oi. You can just send it to std::cout or bar-print it.
In below example __ C; can be replaced with cout << C;. Equivalent code and output is shown in comments:
vint C {1,2,3}; __ C; // vector<int> C{1,2,3};
// cout << "{";
// for(auto it=C.begin(); it!=C.end()-1; it++)
// cout << *it << ", ";
// if(!C.empty()) cout << C.back();
// cout << "}\n";
// prints: {1, 2, 3}
int C[] {1,2,3}; __ C; // {1,2,3}
array<int,3> C {1,2,3}; __ C; // {1,2,3}
tuple<int,int> C {1,2}; __ C; // ⟨1, 2⟩
map<int,int> C {{1,2},{3,4}}; __ C; // {⟨1,2⟩, ⟨3,4⟩}
vector<vint> C {{1,2},{3,4}}; __ C; // {{1, 2}, {3, 4}}
Same for input:
echo 1 2 | scc 'vint C; cin >> C; C' // {1,2}
echo 1 2 | scc 'int C[2]; cin >> C; C' // {1,2}
echo 1 2 | scc 'tuple<int,int> C; cin >> C; C' // ⟨1,2⟩
echo 1 2 | scc 'array<int,2> C; cin >> C; C' // {1,2}
echo 1 2 | scc 'set<int> C; cin >> C; C' // {1,2}
echo 1 2 3 4| scc 'map<int,int> C; cin >> C; C' // {⟨1,2⟩, ⟨3,4⟩}
If a container have non-zero length, then the corresponding number of elements will be read. If container is empty then input will be EOF-terminated.
Object IN
Pre-defined object in can be used as value in expression which is read from std::cin.
int i(in); // int i; cin >> i; float x = 1.1 + float(in); // float y; cin >> y; float x = 1.1 + y;
|
Object in does not check for EOF. Use only in context where you can ignore or do not expect EOF. |
To input a container:
vint V = in(10); vint W = in; // Till EOF. Note: we can not use: vint W(in);
Here is example of C++ vs SCC input where we need to read a number and than corresponding number of container elements:
int N;
cin >> N;
vector<int> V(N);
for(int i=0; i<N; i++)
cin >> V[i];
With object in:
vint V = in(in);
IO.H - Standalone Use
File io.h can be used as standalone, independent include.
#include <io.h>
int main() {
__ "hello world";
}
Includes simple.h, cj.h and stl.h can also be used independently.