static
variables remain in memory even after
leaving the declaring scope
#include <iostream> #include <cstdio> // equivalent to <stdio.h> using namespace std; int globalVariable = 0; // for everbody int myFunction(int a) // call by value { static int storeValue = 0; // executed only (!) at first function call storeValue++; // counting number of times called printf("myFunction : %3d %5d\n",storeValue, globalVariable); globalVariable += 100; a = a + 1; return a + 1; } int main() { int mainInt = 10; int returnInt = myFunction(mainInt); // printf("mainInt : %3d\n",mainInt); printf("returnInt : %3d\n",returnInt); // globalVariable += 10; returnInt = myFunction(mainInt); globalVariable += 10; returnInt = myFunction(mainInt); globalVariable += 10; returnInt = myFunction(mainInt); return 1; }
#include <iostream> #include <stdio.h> // c-type output with printf using namespace std; int myReferenceCall(int &a) // call by reference { a = a + 1; // changing a return a + 1; } int myPointerCall(int *b) // calling with a pointer { *b = (*b) * 3; // (*b) is the value return *b; } int main() { int beforeReference = 10; int beforePointer = 10; int referenceInt = myReferenceCall(beforeReference); int pointerInt = myPointerCall(&beforePointer); printf("beforeReference : %5d\n",beforeReference); printf("referenceInt : %5d\n",referenceInt); // printf("\n"); // printf("beforePointer : %5d\n",beforePointer); printf("pointerInt : %5d\n",pointerInt); return 1; }
void myFunction(int* param)
(array as an pointer)void myFunction(int param[10])
(full array definition)void myFunction(int param[])
(size undefined)size_t
: unsigned integer type, capable of
storing the maximum size of theoretically possible objects
./a.out 4 6 3 7 1
#include <iostream> #include <stdio.h> // c-type output with printf #include <cstdlib> // for atof using namespace std; void ordering(int sizeA, int a[]) // note: a is a pointer and hence { // sizeof(a) / sizeof(a[0]); // does not work anymore printf("# in ordering(): sizeof(a) = %d\n",(int)sizeof(&a)); printf("# in ordering(): sizeof(a[0]) = %d\n",(int)sizeof(a[0])); int xx; for (int i=0;i<sizeA;i++) for (int j=i+1;j<sizeA;j++) if (a[i]>a[j]) { xx = a[i]; a[i] = a[j]; a[j] = xx; } } // end of ordering() int main(int argLength, char* argValues[]) { size_t arraySize = argLength-1; int myArray[arraySize]; // for (int k=0; k<arraySize; k++) myArray[k] = atof(argValues[k+1]); // printf("\n"); printf(" input array: "); for (int k=0; k<arraySize; k++) printf("%5d",myArray[k]); printf("\n"); // printf("# in main(): sizeof(myArray) = %d\n",(int)sizeof(myArray)); ordering(arraySize,myArray); // printf("\n"); printf("orderd array: "); for (int k=0; k<arraySize; k++) printf("%5d",myArray[k]); printf("\n"); // return 1; }
const int c1 = 42; // an integer with constant value int const c2 = 24; // idem: a constant integer // const int * c3; // a pointer to an integer with constant value int const * c4; // idem: a pointer to a constant integer // int * const c5; // a constant (pointer to an integer) // const int * const c6; // a constant (pointer to an integer) with constant value int const * const c7; // idem: a constant pointer to constant integer
#include <iostream> #include <stdio.h> // c-type output with printf using namespace std; void printArray(const int arraySize, const int a[]) // a[0] = 10; not possible { printf("\n"); printf("in printArray:"); for (int k=0; k<arraySize; k++) printf("%5d",a[k]); printf("\n"); } int main() { const int arraySize = 5; int myArray[arraySize] = {0,33,7,44,-10}; // printArray(arraySize, myArray); // return 1; }
void function_1(int par1) // call by value (copy) { par1 = 46; // not changed outside } // void function_2(int &par2) // call by reference (not by pointer) { par2 = 42; // changed outside } // void function_2(int *par2) // calling by pointer { *par2 = 24; // changed outside } // void function_3(const int &par3) // calling a reference to (const int) { // par3 = 42; not allowed printf("printing : %5d\n",par3); // ok } // void function_4(const int *par4) // calling by pointer to (const int) { // *par4 = 24; not allowed printf("printing : %5d\n",*par4); // ok }
namespace namespaceName { .. }
namespaceName::{ .. }
, for functions and variables, and using namespace namespaceName
otherwise
inline
functions are expanded everwhere they are called
(perfomance boosting)#include <iostream> #include <stdio.h> // c-type output with printf using namespace std; // for everthing to come namespace Tom { void aFunction(int a) // Tom has a function {printf("Hi %d, welcome to the namespace of Tom!\n",a);} } namespace Lara { void aFunction(int a) // Lara has a function too {printf("Hi %d, welcome to the namespace of Lara!\n",a);} inline int plus4(int a) // code replacement when called {return a += 4;} } int main() { int mainInt = 10; // Tom::aFunction(mainInt); mainInt = Lara::plus4(mainInt); Lara::aFunction(mainInt); return 1; }
doxygen
test.cpp creates html/lates
documentation pages
/** @brief illustrates function naming and doxygen documentation * @file functionNaming.cpp */ #include <iostream> #include <stdio.h> // c-type output with printf using namespace std; /** @return absolute value of an double */ double myAbs(double a) { printf(" : using double myAbs(double a)\n"); return (a>0.0)?a:(-a); } /** @return absolute value of an int * @author Superior Programmer * @date most exciting day of year * @version last version before final version * @brief comment block illustration */ int myAbs(int a) // alowed { printf(" : using int myAbs(int a)\n"); return (a>0.0)?a:(-a); } /** @brief entry point */ int main() { double inA; int intInA; printf("please enter a number : "); cin >> inA; intInA = (int)inA; // printf("\n"); printf(" inA : %8.2f\n",inA); printf("|inA| : %8.2f\n",myAbs(inA)); printf("\n"); printf(" intInA : %8d\n",intInA); printf("|intInA| : %8d\n",myAbs(intInA)); return 1; }
#include <iostream> #include <stdio.h> // c-type output with printf using namespace std; // -- --------------------------- // -- max for all even data types // -- --------------------------- template <typename T> // T can be: int, double, ... T maxT(T a, T b) // for: return and argument types { return (a>b)?a:b; } // -- ----------------------- // -- swapping two variables // -- ---------------------- template <typename T> void swapVariables(T &var1, T &var2) // call by value { T xx = var1; var1 = var2; var2 = xx; } // -- ---- // -- main // -- ---- int main() { double inA, inB; printf("please enter two real numbers : "); cin >> inA >> inB; // printf("\n"); printf("your input : %7.3f %7.3f\n",inA,inB); swapVariables(inA,inB); printf("your input : %7.3f %7.3f\n",inA,inB); // printf("\n"); printf("the larger real number is : %7.3f\n",maxT(inA,inB)); int intInA = (int)inA; int intInB = (int)inB; printf("the larger int number is : %7d\n",maxT(intInA,intInB)); printf("\n"); // return 1; }
#include <iostream> /* standard IO */ #include <stdio.h> /* for printf */ #include <cstdlib> /* for atof */ #include <stdlib.h> /* srand, rand */ #include <time.h> /* for the time */ using namespace std; // -- ---------------------------- // -- ordering for all array types // -- ---------------------------- template <typename T> void ordering(int sizeA,T a[]) // note: a is a pointer and hence { T xx; for (int i=0;i<sizeA;i++) for (int j=i+1;j<sizeA;j++) if (a[i]>a[j]) { xx = a[i]; a[i] = a[j]; a[j] = xx; } } // end of ordering() // -- --------------------------- // -- generate a random int array // -- --------------------------- void randArray(int sizeA, int a[], int range) { srand( (unsigned)time( NULL ) ); // random seed for (int i=0;i<sizeA;i++) a[i] = (int)(range*(rand()/(double)RAND_MAX)); // (..) important! } // -- ------------------------------------ // -- recursive search of an ordered array // -- ------------------------------------ template <typename T> // any type: int, double, .. int recursiveSearch(T sortedArray[], int first, int last, T key) { if (first <= last) { int mid = (first + last) / 2; // compute mid point. if (key == sortedArray[mid]) return mid; // found it. else if (key < sortedArray[mid]) return recursiveSearch(sortedArray, first, mid-1, key); // call youself for the lower part of the array else return recursiveSearch(sortedArray, mid+1, last, key); // call ourself for the upper part of the array } return -(first + 1); // failed to find key } // -- ---- // -- main // -- ---- int main(int argLength, char* argValues[]) { const int sizeA = 10; int range = 20; int a[sizeA] = {0}; // initializing to zero randArray(sizeA,a,range); // generating random entries // printf("\n"); printf(" input array: "); for (int k=0; k<sizeA; k++) printf("%4d",a[k]); printf("\n"); // ordering(sizeA,a); // ordering the array // printf("\n"); printf("orderd array: "); for (int k=0; k<sizeA; k++) printf("%4d",a[k]); printf("\n"); // int guess; printf("\n"); printf("please guess a number: "); cin >> guess; // guessing a number // int searchResult = recursiveSearch(a,0,sizeA-1,guess); printf("\n"); printf("your search result: %4d\n ",searchResult); // return 1; }
#include <iostream> // standard IO #include <stdio.h> // for printf using namespace std; double geometricSeries(double x, bool starting=true) // the second argument is optional { static const double accuracy = 0.000001; static double factor; static double result; if (starting) { factor = 1.0; // x*x* ... *x result = 0.0; // the sum over powers } result += factor; factor *= x; // // printf("factor, result %12.8f %12.8f\n",factor, result); // if (factor*factor>accuracy*accuracy) geometricSeries(x, false); // return result; } int main() { double x = 0.4; double result = geometricSeries(x); // called only with a single argument printf("\n"); printf("x, result, exact %6.2f %16.8f %12.8f\n",x , result,1.0/(1.0-x)); return 1; }
typedef void (*FF_void_int)(int)
defines a new type: /** @brief function pointers may be passed as arguments to other funcions * @file functionPointers.cpp */ #include <iostream> /* standard IO */ #include <stdio.h> /* for printf */ #include <stdlib.h> /* srand, rand */ #include <time.h> /* for the time */ using namespace std; /** @brief defining a pointer to a void functions with int argument */ typedef void (*FF_void_int)(int); // new types should be global /** @brief a dummy first function */ void firstFunction(int a) { printf(" firstFunction(): a : %d\n",a); } /** @brief a dummy second function */ void secondFunction(int a) { printf("secondFunction(): a*a : %d\n",a*a); } /** @brief entry point */ int main() { FF_void_int pointerToFunction; // srand( (unsigned)time( NULL ) ); // initializing the random number generator for (int i=0;i<10;i++) { pointerToFunction = firstFunction; // functionsa are anyhow pointers // pointerToFunction = &firstFunction; // also ok // pointerToFunction = *firstFunction; // even this! // if ((rand()%2)==1) pointerToFunction = *secondFunction; // pointerToFunction(rand()%10); // calling like this // (*pointerToFunction)(11); // or like this } // return 1; }
#include <iostream> // standard IO #include <stdio.h> // for printf #include <math.h> // math #include <assert.h> // (`assert()' calls abort if arg not true) using namespace std; typedef double (*FF_double_double)(double); // pointer to function // --- ------------------- // --- defining integrands // --- ------------------- inline double myLog_1(double x) { assert(x>0.0); // should always be used double xx = log(1.0+x)/x; return xx*12.0/(M_PI*M_PI); } inline double mySin_1(double x) { const double a = 5.0*0.5*M_PI; const double b = 3.0*0.5*M_PI; return 1.0/(a+b*sin(x)); } // --- -------------------------- // --- defining simple integrator // --- -------------------------- double simpleIntegrate(FF_double_double integrand, // integrating the integrand double lowerBound, // from the lower to the double upperBound) // upper bound { assert(upperBound>lowerBound); int nSteps = 10; double x, deltaX = (upperBound-lowerBound)/nSteps; double result = 0.0; // for (int iSteps=0;iSteps<nSteps;iSteps++) { x = lowerBound + (iSteps+0.5)*deltaX; result += integrand(x)*deltaX; // simplest } return result; } // end of simpleIntegrate() // --- ---- // --- main // --- ---- int main() { double lowerBound = 0.0; double upperBound = 1.0; double result; // result = simpleIntegrate(myLog_1,lowerBound,upperBound); printf("integrating %25s from %5.2f to %5.2f : %19.16f\n", "myLog_1", lowerBound, upperBound,result); printf("\n"); // lowerBound = 0.0; upperBound = 2.0*M_PI; result = simpleIntegrate(mySin_1,lowerBound,upperBound); printf("integrating %25s from %5.2f to %5.2f : %19.16f\n", "mySin_1", lowerBound, upperBound,result); // double (*myFunctionPointer)(double); // no type definition needed here myFunctionPointer = mySin_1; printf("integrating %25s from %5.2f to %5.2f : %19.16f\n", "using myFunctionPointer", lowerBound, upperBound,result); // return 1; }
#include <iostream> // standard IO #include <stdio.h> // for printf #include <math.h> // math #include <assert.h> // (`assert()' calls abort if arg not true) using namespace std; /** @brief function type definition */ typedef double (*FF_double_double)(double); /** @brief Euler integrator */ double simpleIntegrate(FF_double_double integrand, double lowerBound, double upperBound) { assert(upperBound>lowerBound); int nSteps = 10; double x, deltaX = (upperBound-lowerBound)/nSteps; double result = 0.0; // for (int iSteps=0; iSteps < nSteps; iSteps++) { x = lowerBound + (iSteps+0.5)*deltaX; result += integrand(x)*deltaX; } return result; } /** @brief entry point */ int main() { double lowerBound = 0.0; double upperBound = 1.0; double result; FF_double_double myFunction = // binding lambda expression to function pointer [](double a){return 3.0*a*a;}; // lambda expresion result = simpleIntegrate(myFunction,lowerBound,upperBound); printf("integrating %18s from %5.2f to %5.2f yields: %12.8f\n\n", "f(x)=3*x*x ", lowerBound, upperBound,result); result = simpleIntegrate([](double a){return 6.0*a*(1.0-a);} // locally defined function ,lowerBound,upperBound); printf("integrating %18s from %5.2f to %5.2f yields: %12.8f\n\n", "f(x)=6*x*(1-x)", lowerBound, upperBound,result); // constants, as needd for array delimiters, can be evaluated // on the fly by lambda expressions const int fibo5 = []() { // assigning const. variable to lambda expresssion int a=1,b=1,c=0; for (int i=0;i<5;i++) {c=a+b;a=b;b=c;} return c; }(); // () call lambda expression printf("constant variable value: %4d : \n\n", fibo5); // capture the counting variable by reference and do stuff with it double rr=1.0; for (int i=0; // for loop start statement i<100; // for loop condition [&i](){printf("%3d :",i);i++;}() // for loop loop-statement ) { rr = rr*0.999;} // for loop body cout << endl; return 1; }
#include <iostream> using namespace std; /** a global array */ double vals[] = {10.1, 20.2, 30.3, 40.4, 50.5}; /** a function returning the pointer (reference) * to the ith element of the global array */ double& setValue(int i) {return vals[i]; } /** a standard getter */ double getValue(int i) {return vals[i]; } /** just printing the array content */ template<int size> void printArray(double inArray[size]) { for (int i=0; i<size; i++) { cout << "vals[" << i << "] = "; cout << vals[i] << endl; } } /** entry point */ int main () { cout << "value before change" << endl; printArray<5>(vals); setValue(1) = 3.0*getValue(1); // change 2nd element setValue(3) = 44.7; // change 4th element cout << "value after change" << endl; printArray<5>(vals); return 0; }
g++ main.cpp add.cpp
, or with
g++ *.cpp
(only if directory is otherwise clean)
for complex projects put all compiling into a
makefile (Linux script)
// --- ----------------- // --- the file main.cpp // --- ----------------- #include <iostream> using namespace std; int add(int x, int y); // forward declaration int main() { cout << endl; cout << "the sum of 3 and 4 is: " << add(3, 4) << endl; cout << endl; return 1; }
// --- ---------------- // --- the file add.cpp // --- ---------------- int add(int x, int y) { return x + y; }
<iostream.h>
old version of C++ (before standardization) <iostream>
new version of C++ (after standardization) <cstdlib>
old C version, equivalent to
<stdlib.h>
#include <iostream.h>
: search in compiler path#include "myHeaderFile.h"
: search in current directory
// --- ----------------- // --- the file main.cpp // --- ----------------- #include <iostream> #include "add.h" // my own header file using namespace std; int main() { cout << endl; cout << "the sum of 3 and 4 is: " << add(3, 4) << endl; cout << endl; return 1; }
// --- -------------- // --- the file add.h // --- -------------- int add(int x, int y); // forward declaration (function prototype)
// --- ---------------- // --- the file add.cpp // --- ---------------- int add(int x, int y) { return x + y; }
// --- ---------------------------------- // --- the file add.h with a header guard // --- ---------------------------------- #ifndef add_INCLUDED // is the identifier "add_INCLUDED" not yet defined (if not defined)? #define add_INCLUDED // define "add_INCLUDED" int add(int x, int y); // forward declaration (function prototype) #endif // end of if-macro
stoch.c
: 2216 lines / 71 asserts more stoch.cV
/* July 2001, Claudius Gros * stochastic series expansion with worm updates, here * lattice with periodic boundary conditions or infinite lattices */ /* g++ -O3 -DNDEBUG -o stoch.e stoch.c (on a Linux machine) */ /* -DNDEBUG turns the assert() off */ #include <iostream> // (input/ouput) #include <iomanip> // (manipulating input/ouput with `setw()' etc) #include <fstream> // (in/output on files) #include <math.h> // (math's commands) #include <assert.h> // (`assert()' calls abort if arg not true), // turnd off with -DNDEBUG #include <time.h> // ('clock()' measures time in nanoseconds) using namespace std; /* contains the classes * ==================== * A_SITE : all static information relevant for given site * A_BOND : all static information relevant for a specfic bond * A_LINK : a link in the stochastic series expansion * SYSTEM : contains a variable array with all links and other data * : characterizing the system via stochastic series expansion. * : SYSTEM.diagonal_update() does the full diagonal update, * : i.e. adding and removing diagonal links * : SYSTEM.loop_update() constructs a full loop */ /* contains the soubroutines * ========================= * spin_output() : diagnostic output: spin-configuration and bond-types * link_output() : diagnostic output: links in between the links * bond_output() : diagnostic output: bonds * initial_hyper() : intializes the the lattice (for hypercubic lattices) * initial_fromFile() : reads lattice from file 'stoch.input' * expectationValues() : evaluates for given data mean, varianz, auto-tau * measure_chi() : measures the magnetization (q=0 and q=pi) and chi's * measure_cV() : measures the internal energy and spezific heat * timeInSeconds() : returns running time * ggubs() : random-number generator * min() : returns the minimum of to numbers (double,double)--> double * abs() : returns the absolute value (double)--> double * main() : here the program starts */ extern double ggubs(); // forward declaration, neccessary in old-fashion c++ extern double min(double,double); // forward declaration, old-fashion c++ /* the following global constants are defined * ========================================== * xL, yL, zL : # unit-cells in x-/y-/z-direction * dimension : dimension of the lattice * nSites : total number if sites * nBonds : total number of bonds * nHamil : Hamiltonian = sum_{i=0}%{N_hamil-1} H_i * = # of spin configuration on a cluster * nParHamil : number of parameters in Hamiltonian * Jxx,Jzz,Bz : global coupling constants, longitudinal magnetic field * dimerization: dimerization of interaction in between bonds * nBondTypes : number of different bonds (==spin configurations) * : == 2 (in general) == 1 (for B==0) * nBranchings : number of possible worm branchings at a given bond [1,2] * maxMCsteps : maximum number of MC-steps * smallNumber : a small number == zero */ /* The following global variables are defined just behind the * respective class definition : * * A_SITE allSites[nSites]; : array with all sites * A_BOND allBonds[nBonds]; : array with all bonds * SYSTEM system; : class which all links and other system information */ const int xL = 10; // if (xL*yL*zL==1) --> read from file 'stoch.input' const int yL = 10; const int zL = 1; const int dimension = (xL*yL*zL==1)?3:( (yL*zL==1)?1:( (zL==1)?2:3 ) ); // const int nSites = (xL*yL*zL==1)?8:( xL*yL*zL); const int nBonds = (xL*yL*zL==1)?12:( dimension*nSites ); // const int nParHamil = 6; const double Jxx = 1.00; const double Jzz = 1.00; const double Bz = 0.0; const double dimerization = 0.0; // const int nBondTypes = 6; // : 'iBondTypes' const int nBranchings = 1; // : 'ibranchings' const int maxMCsteps = 20000; // : 'iMC' const double smallNumber = 0.0000000001; // // nBondTypes = 6 corresponds to the following six spin configurations // ==================================================================== // // ferro(1) = + + anti_ferro(1) = + - spin-flip(1) = - + // [0] + + [2] + - [4] + - // // ferro(2) = - - anti_ferro(2) = - + spin_flip(2) = + - // [1] - - [3] - + [5] - + // // /* ******************************* */ /* ***** class A_SITE ******* */ /* ******************************* */ // /* contains for following member functions * ======================================= * set/get_coordinate_X/Y/Z() : set/get the X/Y/Z coordinate of the lattice site */ // class A_SITE { public: // inline void set_coordinate_X(int XX) {assert(dimension>=1); coordinates[0]=XX; } inline int get_coordinate_X() {assert(dimension>=1); return coordinates[0]; } // inline void set_coordinate_Y(int YY) {assert(dimension>=2); coordinates[1]=YY; } inline int get_coordinate_Y() {assert(dimension>=2); return coordinates[1]; } // inline void set_coordinate_Z(int ZZ) {assert(dimension>=3); coordinates[2]=ZZ; } inline int get_coordinate_Z() {assert(dimension>=3); return coordinates[2]; } // inline void set_sublattice(int AorB) {assert(AorB*AorB==1);sublattice = AorB; } inline int get_sublattice() {return sublattice; } // // ======================================= // the following data characterizes a site // ======================================= // private: int coordinates[dimension]; // vector with the real-space postion int sublattice; // +1/-1 for A-/B-sublattice }; // end of class A_SITE // /* ***************************************** */ /* *** definitions of global variable *** */ /* *** A_SITE allSites[] *** */ /* ***************************************** */ // A_SITE allSites[nSites]; ...