Russian Qt Forum

C++ (Qt)
while (in >> val) 
 arr.push_back(val);
 

C++ (Qt)
if (!in.eof()) 
 // печать ошибки
 

C++ (Qt)
int main(int argc, char** argv) 
{
  std::vector <int> vec;
 
// получаем имя файла из командной строки, если там пусто, то input.txt (по умолчанию)
  std::string iFileName = GetInName(argc, argv);
 
// читаем данные из файла
  int err = ReadData(iFileName, vec);
  if (err) return ShowError(err, &iFileName);
 
// выполняем содержательную часть
  int result;
  err = sumOfMaxAndMin(arr, &result);
  if (err) return ShowError(err, &iFileName);
 
// записываем выходной файл
  std::string oFileName = GetOutName(argc, argv);
  err = WriteResult(oFileName, result);
  if (err) return ShowError(err, &oFileName);
 
  return 0;
}

• Проверить есть ли стул
• Проверить поддерживается ли тип стула
• Попытаться сесть
• Проверить удобно ли сидеть
• Проверить можно ли пододвинуть стул
• Пододвинуть стул

#include <fstream>
#include <conio.h>
#include <iostream>

using namespace std;
int main(int argc, char *argv[])
{
	ifstream input("input.txt");
	if (!input)
	{
		exit(1);
	}

	string source ;
	std::getline(input, source);
	string findString;
	std::getline(input, findString);
	input.close();

	if (findString.size() > source.size())
	{
		exit(1);
	}

	string recursiveString = findString;
	int result = 0;
	for (int i = 0;i != findString.size(); i++)
	{
		recursiveString.insert(0, 1, recursiveString[recursiveString.size()-1]);
		recursiveString.erase(recursiveString.size()-1, 1);
		int pos = -recursiveString.size();
		while(true)
		{
			pos = source.find(recursiveString, pos+recursiveString.size()); 
			if (pos!= -1)
				result++;
			else
				break;
		}
	}
	ofstream out("OUTPUT.txt");
	if (out)
	{
		out << result;
	}
	exit(0);
}

C++ (Qt)
int main(int argc, char** argv) 
{
  std::vector <int> vec;
 
// получаем имя файла из командной строки, если там пусто, то input.txt (по умолчанию)
  std::string iFileName = GetInName(argc, argv);
 
// читаем данные из файла
  int err = ReadData(iFileName, vec);
  if (err) return ShowError(err, &iFileName);
 
// выполняем содержательную часть
  int result;
  err = sumOfMaxAndMin(arr, &result);
  if (err) return ShowError(err, &iFileName);
 
// записываем выходной файл
  std::string oFileName = GetOutName(argc, argv);
  err = WriteResult(oFileName, result);
  if (err) return ShowError(err, &oFileName);
 
  return 0;
}

C++ (Qt)
#include <vector>
#include <string>
#include <iostream>
#include <fstream>
#include <sstream>
#include <algorithm>
 
int readData(const std::string& iFileName, std::vector<int>& arr);
int writeResult(const std::string& oFileName, int &result);
int showError(int err, const std::string& fileName);
int sumOfMaxAndMin(const std::vector<int>& arr, int& result);
 
int main(int argc, char** argv) {
 
    // Массив для хранения входных данных
    std::vector <int> arr;
 
    // Имя входного файла
    std::string iFileName = "input.txt";
 
    // Читаем данные из файла
    int err = readData(iFileName, arr);
    if (err) return showError(err, iFileName);
 
    // Выполняем содержательную часть
    int result;
    err = sumOfMaxAndMin(arr, result);
    if (err) return showError(err, iFileName);
 
    // Записываем выходной файл
    std::string oFileName = "output.txt";
    err = writeResult(oFileName, result);
    if (err) return showError(err, oFileName);
 
    return 0;
}
 
/**
 * Читаем данные из файла
 * 
 * @param iFileName Имя входного файла
 * @param vec Массив, в который будут считаны входные данные
 * @return Код ошибки: 0 - если ошибок нет
 *                     1 - если файл не удалось открыть
 *                     2 - если в файле некорректные данные
 */
int readData(const std::string& iFileName, std::vector<int>& arr) {
 
    // Открываем файл с входными данными
    std::ifstream in;
    in.open(iFileName.c_str());
    if (!in.is_open()) {
        return 1;
    }
 
    // Читаем данные из файла
    int value, err = 0;
    std::string input;
    while (in >> input) {
        if (std::stringstream(input) >> value) {
            arr.push_back(value);
        } else {
            err = 2;
            break;
        }
    }
 
    // Закрываем файл и возвращаем код ошибки
    in.close();
    return err;
}
 
/**
 * Записываем результат выходной в файл
 * 
 * @param iFileName Имя выходного файла
 * @param vec Массив, который нужно записать в файл
 * @return Код ошибки: 0 - если ошибок нет
 *                     1 - если файл не удалось открыть
 *                     2 - если в файле не удалось записать
 */
int writeResult(const std::string& oFileName, int& result) {
 
    // Открываем файл для записи
    std::ofstream out;
    out.open(oFileName.c_str());
    if (!out.is_open()) {
        return 1;
    }
 
    // Записываем данные в файл
    out << result << std::endl;
 
    // Закрываем файл и возвращаем код ошибки
    out.close();
    return 0;
}
 
/**
 * Выводит текст с ошибкой на экран
 * 
 * @param err Код ошибки
 * @param iFileName Имя файла, в котором произошла ошибка
 */
int showError(int err, const std::string& fileName) {
    switch (err) {
        case 1:
            std::cerr << "Error: could not open the file " << fileName.c_str() << std::endl;
            break;
        case 2:
            std::cerr << "Error: incorrect data in the file " << fileName.c_str() << std::endl;
            break;
        default:
            std::cerr << "Error code: " << err << "; file name: " << fileName.c_str() << std::endl;
            break;
    }
 
    return err;
}
 
/**
 * Сумма максимума из чисел с чётными номерами и
 * минимума из чисел с нечётными номерами
 * 
 * @param arr Массив целых чисел
 * @param result Сумма максимума из чисел с чётными номерами и
 * минимума из чисел с нечётными номерами
 * @return Код ошибки
 */
int sumOfMaxAndMin(const std::vector<int>& arr, int& result) {
 
    // Массивы для чисел с чётным и нечётными номерами
    std::vector<int> odd;
    std::vector<int> even;
 
    // Размер входного массива
    std::size_t size = arr.size();
 
    // Сортируем на чётный и нечётные массивы
    for (int i = 0; i < size; ++i) {
        if ((i+1)%2 != 0) {
            odd.push_back(arr[i]);
        } else {
            even.push_back(arr[i]);
        }
    }
 
    // Находим минимальный среди нечётных
    int min = 0;
    if (odd.size() > 0) {
        min = *std::min_element(odd.begin(), odd.end());
    }
 
    // Находим максимальный среди чётных
    int max = 0;
    if (even.size() > 0) {
        max = *std::max_element(even.begin(), even.end());
    }
 
    // Вычисляем результат
    result = max + min;
 
    // Возвращаем код ошибки
    return 0;
}
 

/**
 * Сумма максимума из чисел с чётными номерами и
 * минимума из чисел с нечётными номерами
 * 
 * @param arr Массив целых чисел
 * @param result Сумма максимума из чисел с чётными номерами и
 * минимума из чисел с нечётными номерами
 * @return Код ошибки
 */
int sumOfMaxAndMin(const std::vector<int>& arr, int& result) {
 
    // Массивы для чисел с чётным и нечётными номерами
    std::vector<int> odd;
    std::vector<int> even;
 
    // Размер входного массива
    std::size_t size = arr.size();
 
    // Сортируем на чётный и нечётные массивы
    for (int i = 0; i < size; ++i) {
        if ((i+1)%2 != 0) {
            odd.push_back(arr[i]);
        } else {
            even.push_back(arr[i]);
        }
    }
 
    // Находим минимальный среди нечётных
    int min = 0;
    if (odd.size() > 0) {
        min = *std::min_element(odd.begin(), odd.end());
    }
 
    // Находим максимальный среди чётных
    int max = 0;
    if (even.size() > 0) {
        max = *std::max_element(even.begin(), even.end());
    }
 
    // Вычисляем результат
    result = max + min;
 
    // Возвращаем код ошибки
    return 0;
}

C++ (Qt)
/**
 * Сумма максимума из чисел с чётными номерами и
 * минимума из чисел с нечётными номерами
 * 
 * @param arr Массив целых чисел
 * @return Сумма максимума из чисел с чётными номерами и
 * минимума из чисел с нечётными номерами
 */
int sumOfMaxAndMin(const std::vector<int>& arr) {
 
    // Размер входного массива
    std::size_t size = arr.size();
 
    int min, max;
 
    if (size == 0) {
        return 0;
    } else if (size == 1) {
        return arr[0];
    } else {
        min = arr[0];
        max = arr[1];
        for (int i = 0; i < size; ++i) {
            if ((i+1)%2 != 0) {
                if (arr[i] < min) {
                    min = arr[i];
                }
            } else {
                if (arr[i] > max) {
                    max = arr[i];
                }
            }
        }
    }
 
    return max + min;
}
 

C++ (Qt)
int sumOfMaxAndMin(const std::vector<int>& arr) {
 
    // Размер входного массива
    std::size_t size = arr.size();
 
    int min, max;
 
    if (size == 0) {
        return 0;
    } else if (size == 1) {
        return arr[0];
    } else {
        min = arr[0];
        max = arr[1];
        for (int i = 0; i < size; ++i) {
            if ((i+1)%2 != 0) {
                if (arr[i] < min) {
                    min = arr[i];
                }
            } else {
                if (arr[i] > max) {
                    max = arr[i];
                }
            }
        }
    }
 
    return max + min;
}
 

C++ (Qt)
bool even = (i & 1);  // inverted odd/even (index is one-based)
if (even) {
... 
 

C++ (Qt)
 
    if (size == 0) return 0;
    if (size == 1) return arr[0];
 
    int  min = arr[0];
    int  max = arr[1];
    for (int i = 2; i < size; ++i) {
     ...
 

C++ (Qt)
int min = 0, max = 0;
 
if (size > 0) {
 min = arr[0];
 if (size > 1) {
  max = arr[1];
  for (int i = 2; i < size; ++i) {
   ....
  }
 } 
} 
return min + max;

/**
 * Сумма максимума из чисел с чётными номерами и
 * минимума из чисел с нечётными номерами
 * 
 * @param arr Массив целых чисел
 * @param result Сумма максимума из чисел с чётными номерами и
 * минимума из чисел с нечётными номерами
 * @return Код ошибки
 */
int sumOfMaxAndMin(const std::vector<int>& arr, int& result) {
 
    // Массивы для чисел с чётным и нечётными номерами
    std::vector<int> odd;
    std::vector<int> even;
 
    // Размер входного массива
    std::size_t size = arr.size();
 
    // Сортируем на чётный и нечётные массивы
    for (int i = 0; i < size; ++i) {
        if ((i+1)%2 != 0) {
            odd.push_back(arr[i]);
        } else {
            even.push_back(arr[i]);
        }
    }
 
    // Находим минимальный среди нечётных
    int min = 0;
    if (odd.size() > 0) {
        min = *std::min_element(odd.begin(), odd.end());
    }
 
    // Находим максимальный среди чётных
    int max = 0;
    if (even.size() > 0) {
        max = *std::max_element(even.begin(), even.end());
    }
 
    // Вычисляем результат
    result = max + min;
 
    // Возвращаем код ошибки
    return 0;
}

C++ (Qt)
#include <stdio.h>
#include <stdlib.h>
#include <iostream>
#include <limits.h>
 
using namespace std;
 
int main()
{
    freopen("input.txt","r",stdin);
    freopen("output.txt","w",stdout);
 
    int n, max = INT_MIN, min = INT_MAX, count = 1;
 
    while( cin >> n )
    {        
        if ( count % 2 )
        {
            if ( min > n )
                min = n;
        } else
        {
            if ( max < n )
                max = n;
        }
 
        count++;
    }
 
    cout << min + max;
 
    return 0;
}
 

C++ (Qt)
#include <vector>
#include <string>
#include <iostream>
#include <fstream>
#include <sstream>
#include <algorithm>
 
int readData(const std::string& iFileName, std::vector<int>& arr);
int writeResult(const std::string& oFileName, int &result);
int showError(int err, const std::string& fileName);
int sumOfMaxAndMin(const std::vector<int>& arr);
 
int main(int argc, char** argv) {
 
    // Массив для хранения входных данных
    std::vector <int> arr;
 
    // Имя входного файла
    std::string iFileName = "input.txt";
 
    // Читаем данные из файла
    int err = readData(iFileName, arr);
    if (err) return showError(err, iFileName);
 
    // Выполняем содержательную часть
    int result = sumOfMaxAndMin(arr);
 
    //    int result;
    //    err = sumOfMaxAndMin(arr, result);
    //    if (err) return showError(err, iFileName);
 
    // Записываем выходной файл
    std::string oFileName = "output.txt";
    err = writeResult(oFileName, result);
    if (err) return showError(err, oFileName);
 
    return 0;
}
 
/**
 * Читаем данные из файла
 * 
 * @param iFileName Имя входного файла
 * @param vec Массив, в который будут считаны входные данные
 * @return Код ошибки: 0 - если ошибок нет
 *                     1 - если файл не удалось открыть
 *                     2 - если в файле некорректные данные
 */
int readData(const std::string& iFileName, std::vector<int>& arr) {
 
    // Открываем файл с входными данными
    std::ifstream in;
    in.open(iFileName.c_str());
    if (!in.is_open()) {
        return 1;
    }
 
    // Читаем данные из файла
    int value, err = 0;
    std::string input;
    while (in >> input) {
        if (std::stringstream(input) >> value) {
            arr.push_back(value);
        } else {
            err = 2;
            break;
        }
    }
 
    // Закрываем файл и возвращаем код ошибки
    in.close();
    return err;
}
 
/**
 * Записываем результат выходной в файл
 * 
 * @param iFileName Имя выходного файла
 * @param vec Массив, который нужно записать в файл
 * @return Код ошибки: 0 - если ошибок нет
 *                     1 - если файл не удалось открыть
 *                     2 - если в файле не удалось записать
 */
int writeResult(const std::string& oFileName, int& result) {
 
    // Открываем файл для записи
    std::ofstream out;
    out.open(oFileName.c_str());
    if (!out.is_open()) {
        return 1;
    }
 
    // Записываем данные в файл
    out << result << std::endl;
 
    // Закрываем файл и возвращаем код ошибки
    out.close();
    return 0;
}
 
/**
 * Выводит текст с ошибкой на экран
 * 
 * @param err Код ошибки
 * @param iFileName Имя файла, в котором произошла ошибка
 */
int showError(int err, const std::string& fileName) {
    switch (err) {
        case 1:
            std::cerr << "Error: could not open the file " << fileName.c_str() << std::endl;
            break;
        case 2:
            std::cerr << "Error: incorrect data in the file " << fileName.c_str() << std::endl;
            break;
        default:
            std::cerr << "Error code: " << err << "; file name: " << fileName.c_str() << std::endl;
            break;
    }
 
    return err;
}
 
/**
 * Сумма максимума из чисел с чётными номерами и
 * минимума из чисел с нечётными номерами
 * 
 * @param arr Массив целых чисел
 * @return Сумма максимума из чисел с чётными номерами и
 * минимума из чисел с нечётными номерами
 */
int sumOfMaxAndMin(const std::vector<int>& arr) {
 
    // Размер входного массива
    std::size_t size = arr.size();
 
    int min = 0, max = 0;
 
    if (size == 0) return 0;
    if (size == 1) return arr[0];
 
    min = arr[0];
    max = arr[1];
    for (int i = 2; i < size; ++i) {
        if ((i + 1) % 2 != 0) { // inverted odd/even (index is one-based)
            if (arr[i] < min) {
                min = arr[i];
            }
        } else {
            if (arr[i] > max) {
                max = arr[i];
            }
        }
    }
 
    return max + min;
}
 

C++ (Qt)
    QTest::addColumn<int>("first");
    QTest::addColumn<int>("second");
    QTest::addColumn<int>("nbulls_expected");
    QTest::addColumn<int>("ncows_expected");
 
    QTest::newRow("bulls_and_cows_01") << 5671 << 7251 << 1 << 2;
    QTest::newRow("bulls_and_cows_02") << 1234 << 1234 << 4 << 0;
    QTest::newRow("bulls_and_cows_03") << 2034 << 6234 << 2 << 1;
 

C++ (Qt)
/**
 * Возвращает (через ссылки) количество совпадений цифр двух
 * чисел на тех же позициях (быки) и на разных (коровы)
 *
 * @param first Первое число
 * @param second Второе число
 * @param nbulls Возвращаемое значение. Количество совпадений вместе с
 * позицией (быки)
 * @param ncows Возвращаемое значение. Количество совпадений, не
 * учитывая позицию (коровы)
 */
void bulls_and_cows(int first, int second, int &nbulls, int &ncows) {
 
    div_t divresult_first;
    div_t divresult_second;
 
    int first_temp = first;
    int second_temp = second;
 
    std::vector<int> vec_first;
    std::vector<int> vec_second;
 
    const std::size_t nsize = 4;
 
    // Подсчёт быков
    for (std::size_t i = 0; i < nsize; ++i) {
        // Деление с сохранением частного и остатка
        divresult_first = div(first_temp, 10);
        divresult_second = div(second_temp, 10);
 
        // Сохраняем цифры для поиска коров
        vec_first.push_back(divresult_first.rem);
        vec_second.push_back(divresult_second.rem);
 
        // Поиск быков
        if (divresult_first.rem == divresult_second.rem) {
            ++nbulls;
        }
        first_temp = divresult_first.quot;
        second_temp = divresult_second.quot;
    }
 
    // Проверяем, что числа четырёхзначные
    if ( (vec_first.size() != nsize) && (vec_second.size() != nsize) ) {
        return;
    }
 
    // Подсчёт коров
    for (std::size_t i = 0; i < nsize; ++i) {
        std::vector<int>::const_iterator it = std::find(vec_second.begin(), vec_second.end(), vec_first[i]);
        if (it != vec_second.end()) {
            if (*it != vec_second[i]) {
                ++ncows;
            }
        }
    }
}

C++ (Qt)
#include <string>
#include <fstream>
#include <iostream>
#include <cstdlib>
#include <vector>
#include <algorithm>
 
//#define TESTING
 
#ifndef TESTING
int readData(const std::string &iFileName, int &first, int &second);
int writeResult(const std::string& oFileName, int nbulls, int ncows);
int showError(int err, const std::string& fileName);
void bulls_and_cows(int first, int second, int &nbulls, int &ncows);
 
int main(int argc, char** argv) {
 
    // Входные данные
    int first;
    int second;
 
    // Имя входного файла
    std::string iFileName = "input.txt";
 
    // Читаем данные из файла
    int err = readData(iFileName, first, second);
    if (err) return showError(err, iFileName);
 
    // Выполняем содержательную часть
    int nbulls, ncows;
    nbulls = ncows = 0;
    bulls_and_cows(first, second, nbulls, ncows);
 
    // Записываем выходной файл
    std::string oFileName = "output.txt";
    err = writeResult(oFileName, nbulls, ncows);
    if (err) return showError(err, oFileName);
 
    return 0;
}
 
/**
 * Читаем данные из файла
 *
 * @param iFileName Имя входного файла
 * @param vec Массив, в который будут считаны входные данные
 * @return Код ошибки: 0 - если ошибок нет
 *                     1 - если файл не удалось открыть
 *                     2 - если в файле некорректные данные
 */
int readData(const std::string& iFileName, int &first, int &second) {
 
    // Код ошибки
    int err = 0;
 
    // Открываем файл с входными данными
    std::ifstream in;
    in.open(iFileName.c_str());
    if (!in.is_open()) {
        err = 1;
        return err;
    }
 
    // Считываем данные из файла
    if (in >> first >> second) {
        err = 0;
        return err;
    } else {
        err = 2;
        return err;
    }
 
    // Закрываем файл и возвращаем нулевой код ошибки
    in.close();
    return err;
}
 
/**
 * Записываем результат выходной в файл
 *
 * @param iFileName Имя выходного файла
 * @param vec Массив, который нужно записать в файл
 * @return Код ошибки: 0 - если ошибок нет
 *                     1 - если файл не удалось открыть
 *                     2 - если в файле не удалось записать
 */
int writeResult(const std::string& oFileName, int nbulls, int ncows) {
 
    // Открываем файл для записи
    std::ofstream out;
    out.open(oFileName.c_str());
    if (!out.is_open()) {
        return 1;
    }
 
    // Записываем данные в файл
    out << nbulls << " " << ncows << std::endl;
 
    // Закрываем файл и возвращаем код ошибки
    out.close();
    return 0;
}
 
/**
 * Выводит текст с ошибкой на экран
 *
 * @param err Код ошибки
 * @param iFileName Имя файла, в котором произошла ошибка
 */
int showError(int err, const std::string& fileName) {
    switch (err) {
    case 1:
        std::cerr << "Error: could not open the file " << fileName.c_str() << std::endl;
        break;
    case 2:
        std::cerr << "Error: incorrect data in the file " << fileName.c_str() << std::endl;
        break;
    default:
        std::cerr << "Error code: " << err << "; file name: " << fileName.c_str() << std::endl;
        break;
    }
 
    return err;
}
#endif
 
/**
 * Возвращает (через ссылки) количество совпадений цифр двух
 * чисел на тех же позициях (быки) и на разных (коровы)
 *
 * @param first Первое число
 * @param second Второе число
 * @param nbulls Возвращаемое значение. Количество совпадений вместе с
 * позицией (быки)
 * @param ncows Возвращаемое значение. Количество совпадений, не
 * учитывая позицию (коровы)
 */
void bulls_and_cows(int first, int second, int &nbulls, int &ncows) {
 
    div_t divresult_first;
    div_t divresult_second;
 
    int first_temp = first;
    int second_temp = second;
 
    std::vector<int> vec_first;
    std::vector<int> vec_second;
 
    const std::size_t nsize = 4;
 
    // Подсчёт быков
    for (std::size_t i = 0; i < nsize; ++i) {
        // Деление с сохранением частного и остатка
        divresult_first = div(first_temp, 10);
        divresult_second = div(second_temp, 10);
 
        // Сохраняем цифры для поиска коров
        vec_first.push_back(divresult_first.rem);
        vec_second.push_back(divresult_second.rem);
 
        // Поиск быков
        if (divresult_first.rem == divresult_second.rem) {
            ++nbulls;
        }
        first_temp = divresult_first.quot;
        second_temp = divresult_second.quot;
    }
 
    // Проверяем, что числа четырёхзначные
    if ( (vec_first.size() != nsize) && (vec_second.size() != nsize) ) {
        return;
    }
 
    // Подсчёт коров
    for (std::size_t i = 0; i < nsize; ++i) {
        std::vector<int>::const_iterator it = std::find(vec_second.begin(), vec_second.end(), vec_first[i]);
        if (it != vec_second.end()) {
            if (*it != vec_second[i]) {
                ++ncows;
            }
        }
    }
}
 

C++ (Qt)
void bulls_and_cows(int first, int second, int &nbulls, int &ncows) 
 

C++ (Qt)
void bulls_and_cows(int first, int second, int * nbulls, int * ncows) 
 

C++ (Qt)
void bulls_and_cows(int iFirst, int iSecond, int & oBulls, int & oCows) 
 

C++ (Qt)
    // Проверяем, что числа четырёхзначные
    if ( (vec_first.size() != nsize) && (vec_second.size() != nsize) ) {
        return;
    }
 

C++ (Qt)
void CalcBullsCows( const char * s1, const char * s2, int count, int & num_Bull, int & num_Cows )
{
  num_Bull = num_Cows = 0;
  for (int i = 0; i < count; ++i) {
    if (s1[i] == s2[i]) {
     ++num_Bulls;
     continue;
    }
 
   for (int j = 0; j < count; ++j) {
    if (s1[j] == s2[i]) 
     if (s1[j] != s2[j])  { // на всякий случай учтем что цифры могут повторяться
       ++num_Cows;
        break;   
     }
    }
  }
}

C++ (Qt)
/**
 * Записываем результат выходной в файл
 *
 * @param oFileName Имя выходного файла
 * @param vec Массив, который нужно записать в файл
 * @return Код ошибки: 0 - если ошибок нет
 *                     1 - если файл не удалось открыть
 *                     2 - если в файле не удалось записать
 */
int writeResult(const std::string& oFileName, int iBulls, int iCows) {
 
    // Открываем файл для записи
    std::ofstream out;
    out.open(oFileName.c_str());
    if (!out.is_open()) {
        return 1;
    }
 
    // Записываем данные в файл
    out << nbulls << " " << ncows << std::endl;
 
    // Закрываем файл и возвращаем код ошибки
    out.close();
    return 0;
}
 

void func(
  _Out_  int a,
  _In_   int b,
 );

C++ (Qt)
void bulls_and_cows(int iFirst, int iSecond, int & oBulls, int & oCows);

C++ (Qt)
void bulls_and_cows(int firstNumber, int secondNumber, int & nBulls, int & nCows);

C++ (Qt)
 
if (!out.is_open()) {
 return errFileOpen;

C++ (Qt)
void bulls_and_cows(int iFirst, int iSecond, int & oBulls, int & oCows) 
 

C++ (Qt)
void bulls_and_cows(int firstNumber, int secondNumber, ...)
 

C++ (Qt)
int readData(const std::string & fileName, int & oFirstNumber, int & oSecondNumber);
 

C++ (Qt)
int writeResult(const std::string & fileName, int nBulls, int nCows);
 

C++ (Qt)
int showError(int err, const std::string & fileName);
 

C++ (Qt)
void bulls_and_cows(int firstNumber, int secondNumber, int & onBulls, int & onCows);
 

C++ (Qt)
bulls_and_cows(first, second, nBulls, nCows);

C++ (Qt)
bulls_and_cows(first, second, &nBulls, &nCows);

C++ (Qt)
int main(int argc, char** argv) {
    // ...
    std::string iFileName = "input.txt";
    // ...
    std::string oFileName = "output.txt";
    // ...
}

C++ (Qt)
void bulls_and_cows(int firstNumber, int secondNumber, int &numberOfBulls, int &numberOfCows);
 

C++ (Qt)
     char *x;
     const QString &myString;
     const char * const y = "hello";
 

C++ (Qt)
        // А так - правильно
        int height;
        int width;
        char *nameOfThis;
        char *nameOfThat; 
 

C++ (Qt)
void MyList::scrollToNode( int index, bool selectIt );

C++ (Qt)
void bulls_and_cows(int firstNumber, int secondNumber, int & numberOfBulls, int & numberOfCows) {
    // ...
    const std::size_t nsize = 4;
 
    std::vector<int> vec_first(nsize);
    std::vector<int> vec_second(nsize);
    // ...
}
 

C++ (Qt)
void CalcBullsCows( const TVector & v1, const TVector & v2, int & numBulls, int & numCows )
{
 for (size_t i = 0; i < v2.size(); ++i) {
  TVector:::const_iterator it = std::find(v1.begin(), v1.end(), v2[i]);
  if (it == v1.end()) continue;
  if (std::distance(v1.begin(), it) == i)
   ++numBulls;
  else
   ++numCows;
 } 
}

C++ (Qt)
template <class Cont1, class Cont2>
void CalcBullsCows( const Cont1 & v1, const Cont2 & v2, int & numBulls, int & numCows )
{
..
}
 

C++ (Qt)
int showError(int errorCode, const std::string& fileName) {
    switch (errorCode) {
    case 1:
        std::cerr << "Error: cannot open the file " << fileName.c_str() << std::endl;
        break;
    case 2:
        std::cerr << "Error: cannot write to the file " << fileName.c_str() << std::endl;
        break;
    case 3:
        std::cerr << "Error: incorrect data in the file " << fileName.c_str() << std::endl;
        break;
    default:
        std::cerr << "Error code: " << errorCode << "; file name: " << fileName.c_str() << std::endl;
        break;
    }
 
    return errorCode;
}
 

C++ (Qt)
enum ErrorType {
    errCannotOpenFile,
    errCannotWriteToFile,
    errIncorrectData
};
 
//...
 
int showError(int errorCode, const std::string& fileName) {
    switch (errorCode) {
    case ErrorType::errCannotOpenFile:
        std::cerr << "Error: cannot open the file " << fileName.c_str() << std::endl;
        break;
    case ErrorType::errCannotWriteToFile:
        std::cerr << "Error: cannot write to the file " << fileName.c_str() << std::endl;
        break;
    case ErrorType::errIncorrectData:
        std::cerr << "Error: incorrect data in the file " << fileName.c_str() << std::endl;
        break;
    default:
        std::cerr << "Error code: " << errorCode << "; file name: " << fileName.c_str() << std::endl;
        break;
    }
 
    return errorCode;
}