Przekazanie do funkcji bool lub std::vector<bool>

Witam.
Czy jest możliwe stworzenie funkcji do której można przekazać bool lub std::vector<bool>?
Do funkcji przekazuję std::vector<Color*> oraz dwa std::vector<bool>, dosyć często zdarza się że dwa następne std::vector<bool> są w pełni wypełnione tą samą wartością, więc zamiast wywoływania funkcji w ten sposób:
int Result = Color::Check_And_Search_Colors_With_Time({ &Main_Data.Colors[1], &Main_Data.Colors[2] }, { false, false}, {true, true}, Position, 20, 750);
wolałbym wywołać ją w ten sposób:
int Result = Color::Check_And_Search_Colors_With_Time({ &Main_Data.Colors[1], &Main_Data.Colors[2] }, false, true, Position, 20, 750);

Próbowałem stworzyć potrzebną funkcję w poniższy sposób, jednak otrzymuję błąd przy każdym jej wywołaniu:

template <class T> bool Is_Type_Bool(const T& Type)
{
	return typeid(T) == typeid(bool);
}

template <class T> void Check(const T& Arg)
{
	bool Is_Arg_Bool = Is_Type_Bool(Arg);

	bool Arg_Value = Is_Arg_Bool ? Arg : Arg[0];
}
int WINAPI WinMain(HINSTANCE hInst, HINSTANCE P, LPSTR CMD, int nShowCmd)
{
	bool A = true;

	Check(A);
	Check<std::vector<bool>>({ true });

	return 0;
}

Error	C2109	subscript requires array or pointer type	36
Error	C2446	':': no conversion from 'std::vector<bool,std::allocator<_Ty>>::const_reference' to 'const std::vector<bool,std::allocator<_Ty>>'	36

EDIT: Innym sposobem jest przekazanie do funkcji std::vector z tylko jednym elementem, rozwiązuje to problem, jednak jestem ciekawy czy można ten problem rozwiązać w lepszy sposób.

1. Nie wiem czy jest sens tworzenia funkcji która za pomocą typeid sprawdza czy dany typ jest typem bool, łatwiej to zrobić tak (drugi post) - http://www.dreamincode.net/forums/topic/232710-how-can-i-check-in-templates-if-tboolean/

Czy jest możliwe stworzenie funkcji do której można przekazać bool lub std::vector<bool>?

Tak, da się do funkcji przekazać boola....=_=...
A w przypadku std::vector<bool> jeżeli masz na myśli przekazywanie przez lvalue, to tak, bo std::vector jest CopyAssignable.

Ale gdy piszesz coś takiego:

Jakas_Funkcja({ false, false}, {true, true});

to { false, false }, czy { true, true } traktujesz jako rvalue, więc mógłbyś przy deklaracji tej funkcji zadeklarować te wektory jako rvalue reference.:

void Jakas_Funkcja(std::vector<bool>&& param1, std::vector<bool>&& param2);

zamiast

void Jakas_Funkcja(std::vector<bool> param1, std::vector<bool> param2);

zamiast wywoływania funkcji w ten sposób:

int Result = Color::Check_And_Search_Colors_With_Time({ &Main_Data.Colors[1], &Main_Data.Colors[2] }, { false, false}, {true, true}, Position, 20, 750);

wolałbym wywołać ją w ten sposób:

int Result = Color::Check_And_Search_Colors_With_Time({ &Main_Data.Colors[1], &Main_Data.Colors[2] }, false, true, Position, 20, 750);

Jeżeli wiesz ile będzie elementów, to możesz wypełnić dany wektor daną jedną konkretną wartością za pomocą std::resize(); http://www.cplusplus.com/reference/vector/vector/resize/
albo od razu użyć drugiego konstruktora ( fill constructor ) z std::vector http://www.cplusplus.com/reference/vector/vector/vector/ przy tworzeniu tego wektora

Możesz sie pobawić traitsami.

#include <cstdio>
#include <string>
#include <type_traits>

template<typename T>
void foo_impl(const T& val, std::true_type){
	printf("Bool\n");
}

template<typename T>
void foo_impl(const T& val, std::false_type){
	printf("Nie bool\n");
}

template<typename T>
void foo(const T& val){
	foo_impl(val, std::is_same<T, bool>());
      
}

template<typename T>
void foo1(const T& val){
	if(std::is_same<T, bool>::value){
		printf("Bool\n");
	}
	else{
		printf("Nie bool\n");
	}
}

int main()
{
	foo(true);
	foo(1);
	foo("foo");

}

Ale całkiem spoko, było by chyba użyć w tym przypadku std::initializer_list.

@Kamil9132 użyj przeciążania funkcji, tak by raz przyjmowała 2 boole, a raz wektory booli (btw, jeśli liczba elementów w tych wektorach jest stała to lepszym rozwiązaniem byłoby użycie std::array albo const ref na tablice o stałym rozmiarze).

możesz użyć boost::variant lub struct z std::shared_ptr<void> i enumem

enum będzie podpowiadał, na króty tym castowac pointer

void funkcja(const std::vector<bool> &arg) { }
void funkcja(bool arg) 
{
    funkcja({ arg, arg });
}