class Item
{
	// наполнение не важно
};

class Executor
{
	void Execute(Item* pItem, /*прочие параметры*/....)
	{
		if (pItem && pItem->IsValid())
		{
			ExecuteOneWay(pItem, ....);
		}
		else
		{
			ExecuteAnotherWay(pItem, ....);
		}	
	}
	
	void Execute(const wchar_t* lpItemName, /*прочие параметры*/...);
	{
		if (lpItemName && lpItemName[0] != 0)
		{
			ExecuteOneWayImpl(lpItemName, ....);
		}
		else
		{
			ExecuteAnotherWayImpl(lpItemName, ....);
		}	
	}
}

class CarExecutor : public Executor
{
	void Go(Item* pItem, /*прочие параметры*/....)
	{
		// что-то делаем здесь
		// иногда этого *что-то* много, иногда нет
	
		Executor::Execute(pItem, .....);
	}
	
	void Go(const wchar_t* lpItemName, /*прочие параметры*/...);
	{
		// что-то делаем здесь
		// иногда этого *что-то* много, иногда нет
	
		Executor::Execute(lpItemName, .....);
	}
	
	void Stop(Item* pItem, /*прочие параметры*/....)
	{
		// что-то делаем здесь
		// иногда этого *что-то* много, иногда нет
	
		Executor::Execute(pItem, .....);
	}
	
	void Stop(const wchar_t* lpItemName, /*прочие параметры*/...);
	{
		// что-то делаем здесь
		// иногда этого *что-то* много, иногда нет
	
		Executor::Execute(lpItemName, .....);
	}
}

template<typename T>
void Execute(T* param, /*прочие параметры*/...);
{
	if (param && param[0] != 0)		// первое ОК, второе - бред, если T* - это Item*
	if (param && param->IsValid())		// первое ОК, второе - бред, если T* - это const wchat_t*

	...
}

template<typename T>
void Execute(T* param, /*прочие параметры*/...);
{
	auto bIsItem = std::is_same<T, Item>::value;

	if (bIsItem == false) // вроде бы шаблонный класс, а ведет себя как обычный :(,
	{//  тут есть и другие проблемы, если понадобится использовать производный от Item класс (std::is_base_of ? возможно....)
		if (param && param[0] != 0)	 // первое ОК, второе OK, тк теперь мы знаем что T - это строка
		{
			ExecuteOneWayImpl(param, ....);
		}
		else
		{
			ExecuteAnotherWayImpl(param, ....);
		}
	}
	else
	{
		if (param && param->IsValid())	// первое ОК, второе OK, тк теперь мы знаем что T - это Item
		{
			ExecuteOneWayImpl(param, ....);
		}
		else
		{
			ExecuteAnotherWayImpl(param, ....);
		}	
	}		
}

template
<
	typename T,
	typename Validator
>
class ItemParamBase
{
public:
	ItemParamBase(T* ptr)	{ m_ptr = ptr;		}

private:	
	T* m_ptr;
	
public:
	operator T*() const	{ return m_ptr;		}
	operator BOOL() const	{ return IsValid();	}

public:
	bool IsValid(void) const
	{
		return Validator::IsValid(m_ptr);
	}
};

// и

template <typename T>
struct StringParamValidator
{
	static bool IsValid(T pValue)	{ return (pValue && pValue[0]);		}
};

template <typename T>
struct ItemParamValidator
{
	static bool IsValid(T pValue)	{ return (pValue && pValue->IsValid());	}
};

// тогда

template <typename T> using ItemParamPtr = ItemParamBase<T, ItemParamValidator<T*>>;
template <typename T> using StringParamPtr = ItemParamBase<T, StringParamValidator<T*>>;

template<typename T>
void Executor::Execute(T* pValue, .....)
{
	if (pValue)
		....
	else
		////
}

// как-то так

Execute(StringParamPtr<const wchar_t>(L"bla-bla-bla"), ....);
Execute(ItemParamPtr<Item>(new Item), .....);