Ответы пользователя code_panik по тегу «C++»

Почему нельзя использовать private метод в качестве аргумента для алгоритмов в другом private методе?

code_panik @code_panik

В комментарии Wataru уже указал на вероятную проблему. Метод класса первым аргументом принимает указатель this на объект класса, который этот метод вызывает. То есть вызов objectName.foo(100) компилируется в нечто такое foo(&objectName, 100).
Только вместо std::bind проще использовать лямбду. Если в списке захвата лямбды указать this или =, то всеми видимыми методами класса в лямбде можно пользоваться как обычно, https://godbolt.org/z/e9z76vTY7.

#include <array>
#include <algorithm>
#include <functional>
#include <iostream>

class Container {
public:
    bool isZeroLambda() {
        return std::ranges::all_of(std::begin(ar), std::end(ar),
                [this](auto x) { return isZeroValue(x); });
    }

    bool isZeroBind() {
        auto pred = std::bind(&Container::isZeroValue, this, std::placeholders::_1);
        return std::ranges::all_of(std::begin(ar), std::end(ar), pred);
    }

private:
    bool isZeroValue(int x) { return x == 0; }
    std::array<int, 3> ar{};
};

int main() {
    Container c;
    std::cout << c.isZeroLambda()
        << '\n' << c.isZeroBind();
    return 0;
}

Ответ написан 07 авг.

Комментировать

Как использовать потоки в современном C++ в приложении на основе цикла событий?

code_panik @code_panik

В сущности, async - это thread + promise/future с удобствами: его не нужно join-нить руками, не нужно создавать промежуточный promise, а возвращенный функцией результат и исключения можно получить в вызывающем коде. При этом деструктор объекта future, полученного в результате вызова async, блокирует вызывающий поток до завершения нашей async-функции.
В нашем случае разницы с использованием thread в части отправки сигналов нет, ведь нам по-прежнему придется сигнализировать виджету о завершении сканирования. Это можно сделать в самой функции сканирования. Если я правильно понял, раньше мы это делали в функции scanFinished, которая вызывалась в конце функции сканирования.
Под задачами обычно понимают независимые потоки выполнения (необязательно параллельно), которые можно запустить и забыть, а в конце забрать результат. Потоки сканирования директорий, судя по коду из вопроса, не зависят друг от друга, и мы наш ThreadManager можем разбить на две переменные типа ScanTask

#include <iostream>
#include <future>
#include <atomic>
#include <memory>
#include <string>

class ScanTask {
public:
	struct Result {
		enum {
			Success, Failure, Canceled
		} status;
		std::string message;
	};

	ScanTask(const std::string& dir)
		: canceled_{ false },
		result_{std::async(&ScanTask::scan, this, dir)}
	{ }

	void cancel() {
		canceled_ = true;
	}

	Result result() { 
		return result_.get(); // result_.valid() == false
	}

	Result scan(const std::string& dir) {
		struct Finalize {
			~Finalize() {
				// emit signal scan completed
			}
		} finalizeSignal;

		while (!canceled_ /* && not done */) {
			// .. scan subdirectories
			/*
			if (something failed)
				return {Result::Failure, "Failure"};
			*/
		}
		if (canceled_)
			return { Result::Canceled, std::string("[Canceled] ") + dir };
		return { Result::Success, std::string("[Success] ") + dir };
	}

private:
	std::atomic<bool> canceled_;
	std::future<Result> result_;
};

int main() {
	auto localScanTask = std::make_unique<ScanTask>("a");
	localScanTask->cancel();
	std::cout << localScanTask->result().message << std::endl;

	auto sharedScanTask = std::make_unique<ScanTask>("b");
	sharedScanTask->cancel();
	std::cout << sharedScanTask->result().message << std::endl;
	return 0;
}

Можно было даже не создавать отдельный класс, а в функции-обработчике нажатия кнопки запуска присваивать future члену виджета результат вызова async от анонимной лямбды, как предлагали с thread в ревью. При этом atomic canceled_ можно захватить по ссылке, она была бы общей для всех.

Войдите на сайт