Даны 4 вещественных числа. Определить сколько из них отрицательных.

// Шчитаем
int Count( const float * array, int size, int i )
{
     if( size <= i )
          return 0;
     return (array[i] < 0) + Count(array, size, i+1);
}
 
int main()
{
     float array[4] = { 1.f, -5.f, 3.f, -1.f };
     // Получаем количество отрицательных чисел
     // Без использования оператора цикла
     // Какие мы молодцы то!
     int nNegatives = Count( array, 4, 0 );
 
     return 0;
}

template <class T>
class number {
 
    static int count;
 
public:
    number(T n) { 
        if (n<0) count++;
    }
 
    static int how_much();
 
};
 
template <class T>
int number<T>::count = 0;
 
template<class T>
int number<T>::how_much() {
    return count;
}
 
 
int main(int argc, char* argv[])
{
    number<float> a[4] = { 1.f, -5.f, 3.f, -1.f };
 
    std::cout << number<float>::how_much() <<  '\n';            
 
 
    getchar();
    return 0;
}

#include <iostream>
 
template <int ... Ints>
struct negatives;
 
template <int I, int ... Ints>
struct negatives<I, Ints ...>
{
    static const size_t count = (I < 0 ? 1 : 0) + negatives<Ints ...>::count;
};
 
template <>
struct negatives<>
{
    static const size_t count = 0;
};
    
int main()
{
    std::cout << negatives<int(-1.f), int(-5.f), int(3.f), int(-3.f)>::count << std::endl;
    
    return 0;
}

int main()
{
float a[4] = { -1.0, 5.3f, -2.0f, -3.f };
 
int i = 0;
int count = 0;
NOT_A_LOOP_OPERATOR:
if( a[i] < 0 )
    count++;
i++;
if( i < 4 )
    goto NOT_A_LOOP_OPERATOR;
 
return 0;
}

#include <iostream>
#define negative(x)    ((x < 0) ? 1 : 0)
 
int main(){
    float arr[] = {0.01, -2.2212, -0.012, 4.4};
    for (int i = 0; i < 4; ++i)
        if(negative(arr[i]))
            std::cout << arr[i] << "\n";
     return 0;
}

#include "stdafx.h"
#include <iostream>
using std::cout;
using std::endl;
 
int main(){
    float number1 = -1.43;
    float number2 = 3.87;
    float number3 = 2.31;
    float number4 = -5.12;
    int count = 0;
 
    if(number1 < 0){
        count +=1;
    }
    if(number2 < 0){
        count +=1;
    }
    if(number3 < 0){
        count +=1;
    }
    if(number4 < 0){
        count +=1;
    }
    cout << "Otricatelnyh chisel : " << count << endl;
    system("pause");
    return 0;
}

struct NullType {};
 
template < int V, class U>
struct Typelist
{
    enum { Value = V };
    typedef U Tail;
};
 
#define TYPELIST_1(T1) Typelist<T1, NullType>
#define TYPELIST_2(T1, T2) Typelist<T1, TYPELIST_1(T2) >
#define TYPELIST_3(T1, T2, T3) Typelist<T1, TYPELIST_2(T2, T3) >
#define TYPELIST_4(T1, T2, T3, T4) Typelist<T1, TYPELIST_3(T2, T3, T4) >
 
 
template< class T > struct CountNegative;
 
template<>
struct CountNegative<NullType>
{
    enum { value = 0 };
};
 
template< int V, class U >
struct CountNegative< Typelist<V, U> >
{
    enum { value = (V < 0) + CountNegative<U>::value };
};
 
// Списки значений
typedef TYPELIST_4( int(2.0f), int(-3.4f), int(5.2f), int(-1.7f) ) ValueList1;
typedef TYPELIST_4( int(-52.4f), int(3.1415f), int(9.232f), int(10.72f) ) ValueList2;
 
int _tmain(int argc, _TCHAR* argv[])
{
    cout << "Negative in list 1 = " << CountNegative<ValueList1>::value << endl;
    cout << "Negative in list 2 = " << CountNegative<ValueList2>::value << endl;
    cin.get();
    return 0;
}