Adding programming style examples

basic/mean_modular.cpp

+#include <iostream>
+
+namespace mtools{
+  struct avars{
+    int ncount;
+    int rsum;
+    double amean;
+  };
+
+  void calcave(avars & a){
+    double stemp{static_cast<double>(a.rsum)};
+    double ntemp{static_cast<double>(a.ncount)};
+    a.amean=stemp/ntemp;
+  }
+
+  void updateave(avars & a, int d){
+    a.rsum+=d;
+    a.ncount++;
+  }
+
+  void printave(const avars & a){
+    std::cout <<"Arithmetic mean: " << a.amean<< std::endl;
+  }
+}
+
+int main(){
+
+  mtools::avars a{};
+  int indata{0};
+  std::cout <<"Enter values [Ctrl-D to finish]: " <<std::endl;
+
+  while(std::cin>>indata){
+    mtools::updateave(a,indata);
+    mtools::calcave(a);
+  }
+
+  mtools::printave(a);
+  return 0;
+}

basic/mean_procedure.cpp

+#include <iostream>
+
+int main(){
+
+  int ncount{0},rsum{0},indata{0};
+  double amean{0.};
+
+  std::cout <<"Enter values [Ctrl-D to finish]: " <<std::endl;
+  while(std::cin>>indata){
+    rsum+=indata; // rsum=rsum+indata;
+    ncount++; // ncount=ncount+1;
+    double stemp=static_cast<double>(rsum);
+    double ntemp=static_cast<double>(ncount);
+    amean=(ntemp!=0)?stemp/ntemp:0.;
+  }
+
+  std::cout <<"Arithmetic mean: " << amean<< std::endl;
+  return 0;
+}

basic/mean_procedure_auto.cpp

+#include <iostream>
+
+int main(){
+
+  auto ncount=0,rsum=0,indata=0;
+  auto amean=0.;
+  decltype(rsum/ncount) truncmean;
+
+  std::cout <<"Enter values [Ctrl-D to finish]: \n" ;
+  while(std::cin>>indata){
+    rsum+=indata; // rsum=rsum+indata;
+    ncount++; // ncount=ncount+1;
+    auto stemp=static_cast<double>(rsum);
+    auto ntemp=static_cast<double>(ncount);
+    amean=(ntemp!=0)?stemp/ntemp:0.;
+    truncmean=(ntemp!=0)?rsum/ncount:0;
+  }
+
+  std::cout <<"Arithmetic mean: " << amean<< '\n';
+  std::cout <<"Rounded to int mean: " << truncmean<< std::endl;
+  return 0;
+}

basic/mean_template.cpp

+#include <iostream>
+
+template<typename Data, typename Result> class ave{
+public:
+	// in C++98
+	// typedef Data data_type;
+	// typedef Result result_type;
+  using data_type=Data;
+  using result_type=Result;
+
+  ave(): ncount_(0), rsum_(0), amean_(0) {};
+
+  ave & operator+=(data_type d){
+    rsum_+=d;
+    ncount_++;
+    result_type stemp=static_cast<result_type>(rsum_);
+    result_type ntemp=static_cast<result_type>(ncount_);
+    amean_=stemp/ntemp;
+    return *this;
+  }
+
+  result_type get_ave() const { return amean_;}
+
+
+private:
+    data_type ncount_;
+    data_type rsum_;
+    result_type amean_;
+
+};
+
+
+int main(){
+  // Since C++11
+  using ave_type=ave<int,double>;
+  using data_type=ave<int,double>::data_type;
+
+  ave_type a;
+  data_type indata{};
+  std::cout <<"Enter values [Ctrl-D to finish]: " <<std::endl;
+
+  while(std::cin>>indata){
+    a+=indata;
+  }
+
+  std::cout << "Average: " << a.get_ave() << std::endl;
+  return 0;
+}

basic/mean_template_op.cpp

+#include <iostream>
+#include <cmath> // for std::pow
+
+template<typename Data> struct sum{
+	Data operator()(const Data & a, const Data & b ){
+		return a+b;
+	}
+};
+
+template<typename Data> struct multiply{
+	Data operator()(const Data & a, const Data & b ){
+		return a*b;
+	}
+};
+
+template<typename Result> struct divide{
+	Result operator()(const Result & a, const Result & b ){
+		return a/b;
+	}
+};
+
+template<typename Result> struct nroot{
+	Result operator()(const Result & a, const Result & b ){
+		return std::pow(a,1.0/b);
+	}
+};
+
+
+template<typename Data, typename Result, typename IncrOp, typename ResOp, int InitPar=0 > class mean{
+public:
+	// in C++98 typedef Data data_type; typedef Result result_type;
+  using data_type=Data;
+  using result_type=Result;
+  using incrop_type=IncrOp;
+  using resop_type=ResOp;
+
+  mean(): ncount_{}, rvalue_{static_cast<data_type>(InitPar)}, mean_{} {};
+
+  void increment(Data d){
+	  ncount_++;
+	  rvalue_=increment_(rvalue_,d);
+	  result_type rtemp=static_cast<result_type>(rvalue_);
+	  result_type ntemp=static_cast<result_type>(ncount_);
+	  mean_=result_(rtemp,ntemp);
+  }
+
+  result_type get_ave() const { return mean_;}
+
+private:
+  	IncrOp increment_;
+  	ResOp result_;
+    Data ncount_;
+    Data rvalue_;
+    Result mean_;
+
+};
+
+int main(){
+  // Since C++11
+	using data_type=int;
+	using result_type=double;
+	using sum_type=sum<data_type>;
+	using multiply_type=multiply<data_type>;
+	using divide_type=divide<result_type>;
+	using nroot_type=nroot<result_type>;
+	using arithmetic_type=mean<data_type,result_type,sum_type,divide_type>;
+	using geometrical_type=mean<data_type,result_type,multiply_type,nroot_type,1>;
+
+	arithmetic_type a;
+	geometrical_type b;
+	data_type indata{};
+	std::cout <<"Enter values [Ctrl-D to finish]: " <<std::endl;
+	while(std::cin>>indata){
+		a.increment(indata);
+		b.increment(indata);
+	}
+	std::cout << " Arithmetic mean: " << a.get_ave() << "\n Geometrical mean: " << b.get_ave() << std::endl;
+	return 0;
+}

basic/mean_userdefined.cpp

+#include <iostream>
+
+class ave{
+public:
+  ave(): ncount_(0), rsum_(0), amean_(0) {};
+
+  ave & operator+=(int d){
+    rsum_+=d;
+    ncount_++;
+    double stemp=static_cast<double>(rsum_);
+    double ntemp=static_cast<double>(ncount_);
+    amean_=stemp/ntemp;
+    return *this;
+  }
+
+  double get_ave() const { return amean_;}
+
+
+private:
+    int ncount_;
+    int rsum_;
+    double amean_;
+
+};
+
+
+int main(){
+
+  ave a;
+  int indata{0};
+  std::cout <<"Enter values [Ctrl-D to finish]: " <<std::endl;
+
+  while(std::cin>>indata){
+    a+=indata;
+  }
+
+  std::cout << "Average: " << a.get_ave() << std::endl;
+  return 0;
+}

basic/mean_userdefined_oo.cpp

+#include <iostream>
+#include <cmath> // for std::pow
+#include <vector>
+
+class mean{
+public:
+	mean(){};
+	virtual ~mean(){};
+	virtual mean & add_data(int d) = 0;
+	virtual double get_mean() const =0;
+	virtual void print(std::ostream & o=std::cout) const =0;
+private:
+	mean(const mean & a) = default;
+	mean & operator=(const mean & a) = default;
+
+};
+
+class arithmetic:public mean{
+public:
+	arithmetic(): ncount_{0}, rsum_{0}, amean_{0} {};
+
+	// Use Relaxation return type, the covariant rule
+	arithmetic & add_data(int d) override { *this+=d; return *this; }
+
+	arithmetic & operator+=(int d){
+		rsum_+=d;
+		ncount_++;
+		double stemp=static_cast<double>(rsum_);
+		double ntemp=static_cast<double>(ncount_);
+		amean_=stemp/ntemp;
+		return *this;
+	}
+
+	double get_mean() const override { return amean_;}
+	void print(std::ostream &o) const override {
+		std::cout << " Arithmetic mean: " << get_mean() << std::endl;
+	}
+
+private:
+	int ncount_;
+	int rsum_;
+	double amean_;
+};
+
+class geometric:public mean{
+public:
+	geometric(): ncount_{0}, rproduct_{1}, gmean_{0} {};
+
+	// Use Relaxation return type, the covariant rule
+	geometric & add_data(int d){ *this*=d; return *this; }
+
+	geometric & operator*=(int d){
+		rproduct_*=d;
+		ncount_++;
+		double ptemp=static_cast<double>(rproduct_);
+		double ntemp=static_cast<double>(ncount_);
+		gmean_=std::pow(ptemp,1.0/ntemp);
+		return *this;
+	}
+
+	double get_mean() const { return gmean_;}
+	void print(std::ostream &o) const override {
+		std::cout << " Geometrical mean: " << get_mean() << std::endl;
+	}
+
+private:
+	int ncount_;
+	int rproduct_;
+	double gmean_;
+
+};
+
+int main(){
+
+	arithmetic a;
+	geometric b;
+	std::vector<mean*> means;
+	means.push_back(&a);
+	means.push_back(&b);
+	int indata{0};
+	std::cout <<"Enter values [Ctrl-D to finish]: " <<std::endl;
+
+	while(std::cin>>indata){
+		//    a+=indata;
+		//    b*=indata;
+		for(auto i: means) i->add_data(indata);
+	}
+
+	for(const auto i: means) i->print();//	for(std::vector<mean*>::const_iterator i=means.begin(); i!= means.end(); ++i) (*i)->print();
+
+	return 0;
+}

basic/test_pointer.cpp

+int main(){
+  int a,b[2];
+  float c,d;
+  
+  int *pi,*pii;
+  int ** pb;
+  int *pa[2];
+  float *pf;
+
+  a=2;
+  pi=&a;
+  pii=pi;
+  pi++;
+  c=2.;
+  c=static_cast<float>(*pi);
+  d=*reinterpret_cast<float *>(pi);
+  c=static_cast<float>(*pii);
+  d=*reinterpret_cast<float *> (pii);
+  b[0]=2;
+  b[1]=7;
+  pi=b;
+  pii=&b[1];
+  pb=&pi;
+  pa[0]=&a;
+  pa[1]=&b[1];
+  b[0]=5;
+  a=b[0];
+  pi=&a;
+  pii=b;
+  if(pi==pii) {
+    c = 1.;
+  } else {
+    c = 2.;
+  }
+  if(*pi==*pii) {
+    d = 1.;
+  } else {
+    d = 2.;
+  }
+
+  return 0;
+}

basic/type_size_limits.cpp

+#include <iostream> // for std::cout, std::cin and std::endl
+#include <limits> // for std::nunmeric_limits
+#include <iomanip> // for std::boolalpha
+
+int main(){
+	// Since C++11 we rely on default initialization ... check with GDB or printout the values
+	long int a;
+	long long int b;
+	double c;
+	char d;
+	std::cout << " Size of long int: " << sizeof(a) << "\n Size of long long int: " << sizeof(b) <<'\n';
+	std::cout << " Size of double: " << sizeof(c) << '\n';
+	std::cout << " Size of char: " << sizeof(d) << '\n';
+	std::cout << " The largest float == " << std::numeric_limits<float>::max()
+			  << "\n The smallest float == " << std::numeric_limits<float>::min()
+			  << '\n';
+	std::cout << " Char is signed == " << std::numeric_limits<char>::is_signed;
+	bool e{std::numeric_limits<char>::is_signed};
+	std::cout << " Char is signed == " << std::boolalpha << std::numeric_limits<char>::is_signed
+			  << ", " << e <<"\n Size of bool: " << sizeof(e) << '\n';
+
+	// Here we flush the standard output buffer ...
+	std::cout << std::endl;
+	return 0;
+}
+
+
+