Roman

filein.txt
Petya,K221,1,2,3;Vasya,K222,4,5,6;Senya,K223,7,8,0;Goga,K224,1,2,3;

#include <iostream>
#include <fstream>
#include <vector>
#include <string>
#include <iterator>
#include <algorithm>
using namespace std;

template<typename X = int>
struct Data
{
  X one;
  X two;
  X three;
  Data(X x1 = 0, X x2 = 0, X x3 = 0) : one{x1}, two{x2}, three{x3}
  {}
};

template<typename X = int>
struct DataRecord
{
  pair<string, string> text;
  Data<X> data;
  DataRecord(string _s1 = {}, string _s2 = {},
             X _x1 = 0, X _x2 = 0, X _x3 = 0)
    : text{_s1, _s2}, data{_x1, _x2, _x3}
  {}
};

template<typename X = int>
istream& operator>>(istream& is, DataRecord<X>& record)
{
  char c;
  getline(is, record.text.first, ',');
  getline(is, record.text.second, ',');
  is >> record.data.one;
  is >> c;
  if(c == ',')
  {
    is >> record.data.two;
    is >> c;
    if(c == ',')
    {
      is >> record.data.three;
    }
  }
  is >> c;
  if(c != ';')
  {
    is.clear(ios_base::failbit);
  }
  return is;
}

struct DataSet
{
  vector<DataRecord<>> records;
  DataSet() : records{}{}
  void load(string filename) noexcept;
  Data<> sumsByColumns() noexcept;
};

void DataSet::load(string filename) noexcept
{
  ifstream in(filename);
  if(!in)
  {
    //...
    return;
  }
  copy(istream_iterator<DataRecord<>>{in}, {}, back_inserter(records));
}

Data<> DataSet::sumsByColumns() noexcept
{
  Data<> result;
  for(const auto& rec : records)
  {
    result.one   += rec.data.one;
    result.two   += rec.data.two;
    result.three += rec.data.three;
  }
  return result;
}

int main()
{
  DataSet ds;
  ds.load("C:\\infile.txt");
  Data<> result{ds.sumsByColumns()};

  for(const auto& rec : ds.records)
  {
    cout << rec.text.first << '\t'
         << rec.text.second << '\t'
         << rec.data.one << '\t'
         << rec.data.two << '\t'
         << rec.data.three << '\n';// Если формат записей в файле
                                   // построчный '\n' нужно убрать.
  }

  cout << "\nTotal:\t\t"
       << result.one << '\t'
       << result.two << '\t'
       << result.three << endl;
}

OUT
Petya   K221    1       2       3
Vasya   K222    4       5       6
Senya   K223    7       8       0
Goga    K224    1       2       3

Total:          13      17      12

int ans1 = arrInterval(x,5,start,end);
    printf("%d",ans1);
    int ans2 = arrInterval(y,10,start,end);
    printf("%d",ans2);
    int ans3 = arrInterval(z,15,start,end);
    printf("%d",ans3);
    
    arrReplace(x,5,ans1);
    arrReplace(y,10,ans2);
    arrReplace(z,15,ans3);

#include <algorithm>
#include <iostream>
using namespace std;

template<typename T, int N, int M>
auto count_match(T(&a)[N], T(&b)[M])
{
  size_t match_count = 0;
  sort(begin(b), end(b));
  for(auto& val : a)
  { 
    if(binary_search(begin(b), end(b), val))
    {
      ++match_count;
    }
  }
  return match_count;
}

int main()
{
  int  v[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 0, 22};
  int v2[] = {0, 22, 33, 5, 4, 8, 9, 0, 13};
  
  std::cout << count_match(v, v2);

  cin.get();
}

#include<iostream>
#include<string>
#include<algorithm>
//ru.cppreference.com/w/cpp/algorithm/count

using namespace std;

int main()
{
  string s = "Asdk6949_glsjg+()(& *&%^%$df   gdfg     e$T#%Y KNUYNL  GIK5654";
  cout << count_if(s.begin(), s.end(), ::isalpha) << endl; 
}

#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#include<limits.h>

int main()
{
	srand((unsigned)time(NULL));
	const int n = 4;
	const int m = 3;
	int     idx = 0;
	int   summa = 0;
	int min_sum = INT_MAX;
	int a[n][m];

	for (int i = 0; i < n; i++)
	{
		for (int j = 0; j < m; j++)
		{
			a[i][j] = rand() % 20;
			summa += a[i][j];
			printf("a[%d][%d]=%d\n", i, j, a[i][j]);
		}

		if(min_sum > summa)
    {
      min_sum = summa;
      idx = i;
    }

		printf("summa[%d]=%d\n", i, summa);
		summa = 0;
	}

  printf("min summa[%d]=%d\n", idx, min_sum);

  for(int i = 0; i < m; i++)
  {
    printf("a[%d][%d]=%d\n", idx, i, a[idx][i]);
  }
  return 0;
}

// Functions array
  uint8_t functions_index;
  int (*functions[NUMBER_FUNCTIONS])(String);
  char * functions_names[NUMBER_FUNCTIONS];

void function(char * function_name, int (*f)(String)){

  functions_names[functions_index] = function_name;
  functions[functions_index] = f;
  functions_index++;
}

#include<iostream>
#include<string>
/*
* Будем считать, что std::string это String
*/
#define NUMBER_FUNCTIONS 10
struct aRest
{
  uint8_t functions_index;
  int (*functions[NUMBER_FUNCTIONS])(std::string);
  char* functions_names[NUMBER_FUNCTIONS];
  //...
  aRest() : functions_index(0){};
  void function(char * function_name, int (*f)(std::string))
  {
    functions_names[functions_index] = function_name;
    functions[functions_index] = f;
    functions_index++;
  }
};

class App
{
  aRest bt_rest;
public:
  explicit App() : bt_rest(){};
  //...
  int startManufacturing(std::string command);
  void setup();
  void call(std::string s);// Для теста. Там то же по другому...
  //...
};

int App::startManufacturing(std::string command)
{
  std::cout << "startManufacturing\n"
            << "with command " << command
            << " " << this << std::endl;
  return 1;
}

void App::setup()
{
  bt_rest.function("startManufacturing", (int(*)(std::string))&startManufacturing);
  //reinterpret_cast<int(*)(std::string)>(&startManufacturing)
}

void App::call(std::string s)
{
  bt_rest.functions[0](s);
}

int main()
{
  App ap;
  ap.setup();
  ap.call("COMMAND");
}

#include<iostream>
#include<string>
#include<functional>

#define NUMBER_FUNCTIONS 10
template<typename T>
struct aRest
{
  uint8_t functions_index;

  int (T::*functions[NUMBER_FUNCTIONS])(std::string);
  char* functions_names[NUMBER_FUNCTIONS];
  //...
  aRest() : functions_index(0){};

  void function(char * function_name, int(T::*f)(std::string))
  {
    functions_names[functions_index] = function_name;
    functions[functions_index] = f;
    functions_index++;
  }
};

class App
{
  aRest<App> bt_rest;
public:
  App() : bt_rest(){};
  //...
  int startManufacturing(std::string command);
  void setup();
  void call(std::string fn);
  //...
};

int App::startManufacturing(std::string command)
{
  std::cout << "startManufacturing\n"
            << "with command " << command
            << " " << this << " " << std::endl;
  return 1;
}

void App::setup()
{
  bt_rest.function("startManufacturing", &startManufacturing);
}

void App::call(std::string s)
{
  std::mem_fn(bt_rest.functions[0])(this, s);
}

int main()
{
  App ap;

  ap.setup();

  ap.call("COMMAND");
}

3.4 Control Structures
Normally, statements in a program are executed one after the other in the order in which
they’re written. This is called sequential execution. Various C statements we’ll soon discuss
enable you to specify that the next statement to be executed may be other than the
next one in sequence. This is called transfer of control.
...
...
Bohm and Jacopini’s work demonstrated that all programs could be written in terms
of only three control structures, namely the sequence structure, the selection structure
and the repetition structure. The sequence structure is built into C. Unless directed otherwise,
the computer executes C statements one after the other in the order in which
they’re written. The flowchart segment of Fig. 3.1 illustrates C’s sequence structure.

3.5 The if Selection Statement
Selection statements are used to choose among alternative courses of action. For example,
suppose the passing grade on an exam is 60. The pseudocode statement

if (expr) // start of if-statement
{ // start of block
  int n = 1; // declaration
  printf("%d\n", n); // expression statement
} // end of block, end of if-statement

statement - инструкция
Слово statement обычно переводят на русский термином "оператор". Таким образом, мы и привыкли, что if, while, case и т.п. – это операторы. К сожалению, в С++ этот перевод приводит к трудностям, поскольку имеется термин operator - словом "оператор" естественно было бы переводить его. Из возможных и встречавшихся в русской литературе переводов statement (утверждение, предложение, инструкция) в переводе книжки Струструпа, посвященной третьему стандарту С++, принят термин "инструкция".

expression statement
инструкция-выражение
Инструкция, которая одновременно является и выражением. Примеры: присваивание, вызов функции.

operator - оператор
Встроенная операция языка, такая, как сложение. (Также перегруженная операция, задаваемая функцией-членом класса. -> к подмножеству Си не относится)