Raise to the power problem

[swgh]

Hey guys

I am doing a rather simple exercise but I am not permitted to use the pow() function to do this.

I need to print of all the powers of 2(0) to 2(8) as in 2 x 2 x 2 x2 etc.

I have tried using the base exponent method but I am getting eight zeros as output.

This is what I have tried, can anyone see what I am doing wrong?

#include <stdio.h>

int main ( void ) {
	int i, 
		base = 2,
		res = 0,
		exp = 0;

	while ( exp <= 8 ) {
		for ( i = 1; i <= exp; i++ ) 
			res = res * base;

			printf("%d\n", res);
		exp++;
	}
		
	getchar();

	return 0;
}

[tabstop]

Well, 0*2*2*2*2*2*2*2*2 is zero, after all. Perhaps you don't want a 0 in the product?

[swgh]

Thanks tabstop such a simple mistake too. All I had to do was change res = 0 to res = 2 and zero it before the exp++.

Cheers for pointing me in the right direction!

[blurx]

Shifting left the number 1 by 1 is the same as multiplying by 2. So if x = 1 and you do x << 1, x becomes 2, which is the same as 2^1.

[Sebastiani]

This works as an unoptimized general case for most user defined types:

#include <iostream>
#include <cstdio>
#include <cstdlib>

namespace xtd {
    
template < typename Type, typename Integer >
Type&
raise( Type& lhs, Integer rhs )
{
        static Type
                one = Type( ),
                once = one++;      
        Type const
                value = lhs;
        lhs = one;  
        while( rhs-- > zero )
                lhs *= value;
        return lhs;      
}

template < typename Type, typename Integer >
inline Type&
operator ^=( Type& lhs, Integer rhs )
{
        return raise( lhs, rhs );      
}

template < typename Type, typename Integer >
Type
raised( Type const& lhs, Integer const& rhs )
{
        Type
                tmp( lhs );
        return raise( tmp, rhs );      
}

template < typename Type, typename Integer >
inline Type
operator ^( Type const& lhs, Integer const& rhs )
{
        return raised( lhs, rhs );      
}

} // namespace

using namespace std;
using namespace xtd;

int
main( int argc, char** argv )
{            
        if( argc == 3 )
        {
                cout << raised( strtod( argv[ 1 ], 0 ), atoi( argv[ 2 ] ) ) << endl;
                return 0;
        }
        cout << "raise a number to some power - usage: '" << argv[ 0 ] << " float-value integer-exponent'" << endl;
        return 1;
}

[edit]
Hmm...but what about negative exponents?
[/edit]

[edit]
Is this it?

template < typename Type, typename Integer >
Type&
raise( Type& lhs, Integer rhs )
{
        static Type
                one = Type( ),
                once = one++;         
	Type
		value;	
        if( rhs < Integer( ) )
	{
		rhs = -rhs;		
		value = lhs ? one / lhs : lhs;
	}
	else
                value = lhs;                
        lhs = one;
        while( rhs-- > Type( ) )
                lhs *= value;
        return lhs;      
}

[/edit]

[laserlight]

Fyi, Sebastiani's example is in C++, not C.

[Elysia]

swgh:
Can it be that you do not have had the pleasure of using a debugger?
You ask quite simple problems--simple mistakes--that you should easily be able to solve on your own.

[Sebastiani]

>> Fyi, Sebastiani's example is in C++, not C.

Whoops, wrong forum.