Printable View
i thought you were more than an amature...
or maybe you're just a stuck up SOB that is too good to realize that everybody has to start somewhere, and that would be considered a trick by somebody that's just starting out...
no, i'm not trying to start a flame war...
To fix MSVC6's problem with the scope of variables in a for statement:
And to deal with its problems with the std namespace and C++-style headers:Code:#define for if( 0 ); else for
Code:#ifdef _MSC_VER
#if _MSC_VER < 1300
namespace std {
#endif
#endif
#include <cstdio>
// and whatever else
#ifdef _MSC_VER
#if _MSC_VER < 1300
}
#endif
#endif
I´m not the most experienced programmer, but I´ll try to leave a good one.
When using static variables in a class(or any other place), remember to put a reference to that variable in the definition file, for example:
Code:/* file.h */
class T{
public:
T();
private:
static int tX;
};
/* file.cpp */
#include "file.h"
int T::tX;
T::T(){
tX = 10;
}
A couple I can think of off the top of my head:
Using single quoted characters to initialize integers. For example:
'a' is 8 bits
'aa' = ('a' << 8) + 'a' is 16 bits
etc...
To see if your OS protects memory well, run the following program:
If it does, the program crashes. If it doesn't, the system crashes.Code:int main()
{
for(int* p = (int*)0x1000; ; *(++p) = 0);
}
heres one. why wait until runtime to compute a square root if it can be done at compile time.
Code:template<int N,int LO = 1,int HI = N>
class Sqrt
{
public:
enum { mid = (LO + HI + 1) / 2};
enum { result = ( N < mid * mid) ? Sqrt<N,LO,mid - 1>::result : Sqrt<N,mid,HI>::result};
};
template<int N,int M>
class Sqrt<N,M,M>
{
public:
enum{ result = M};
};
#include<iostream>
int main()
{
std::cout<<"square root of 49 is "<<Sqrt<49>::result<<std::endl;
return 0;
}
Don't forget Fibonacci's
:DCode:template<int N>
struct fibonacci
{
enum { ret = fibonacci<N - 1>::ret + fibonacci<N - 2>::ret };
};
template<>
struct fibonacci<0>
{
enum { ret = 1 };
};
template<>
struct fibonacci<1>
{
enum { ret = 1 };
};
Guys!!!! wait up!!! Please!!!
not here, on my website! please post your tips and tricks there together with your name, and optional email ad and homepage!
tips and tricks collection
please? thanks a lot!!! :)
I was just implying that not even an amatuer would find most of those tricks terribly amazing.Quote:
Originally posted by major_small
i thought you were more than an amature...
or maybe you're just a stuck up SOB that is too good to realize that everybody has to start somewhere, and that would be considered a trick by somebody that's just starting out...
no, i'm not trying to start a flame war...
You're mean; I'm telling my mommy on you. :(
*sniff*
sorry... i was just pointing out that you shouldn't overlook the obvious...
Well, at least you apologized.
Ok, I won't tell my mommy on you. :)
Can anyone explain the above sqrt / fib code? I don't understand the role of the enum....
Following on from Stoned_Coder's metaprogramming example...here's something I was working on for a contest a while ago...it was to add 2 fractions at compile time and rationalize them down....bit of a pig to read!
Code:#include <iostream>
#include <cassert>
//Main struct interface
template <int n1, int d1, int n2, int d2>
struct add_fraction
{
static const int numerator;
static const int denominator;
};
//Specialisation 1: Subvert functionality
template <int n1, int d1>
struct add_fraction<n1,d1,0,0>
{
static const int denominator = add_fraction<d1,n1%d1,0,0>::denominator;
};
//Specialisation 2: Assign value
template <int n1>
struct add_fraction<n1,0,0,0>
{
static const int denominator = n1;
};
//The Numerator
template <int n1, int d1, int n2, int d2>
const int add_fraction<n1,d1,n2,d2>::numerator =
((((d2*d1)/d1)*n1)+(((d2*d1)/d2)*n2)) /
add_fraction<((((d2*d1)/d1)*n1)+(((d2*d1)/d2)*n2)),
((d2*d1)%((((d2*d1)/d1)*n1)+(((d2*d1)/d2)*n2))),0,0>::denominator;
//The Denominator
template <int n1, int d1, int n2, int d2>
const int add_fraction<n1,d1,n2,d2>::denominator = (d1*d2)/
add_fraction<((((d2*d1)/d1)*n1)+(((d2*d1)/d2)*n2)),
((d2*d1)%((((d2*d1)/d1)*n1)+(((d2*d1)/d2)*n2))),0,0>::denominator;
int main() {
typedef add_fraction<2,3,1,12> three_fourths;
assert(three_fourths::numerator==3);
assert(three_fourths::denominator==4);
std::cout << three_fourths::numerator;
std::cout << std::endl << "--" << std::endl;
std::cout << three_fourths::denominator;
}
To explain this lets look at the simpler fibonacci example. Lets refresh ourselves of the code...Quote:
Can anyone explain the above sqrt / fib code? I don't understand the role of the enum....
That is 1 template struct and 2 full specializations. The enum held is a compile time constant. It could have equally have been a static const int as in fordy's example.Code:template<int N>
struct fibonacci
{
enum { ret = fibonacci<N - 1>::ret + fibonacci<N - 2>::ret };
};
template<>
struct fibonacci<0>
{
enum { ret = 1 };
};
template<>
struct fibonacci<1>
{
enum { ret = 1 };
};
lets look at fibonacci<0>::ret its 1
fibonacci<1>::ret is also 1
fibonacci<2>::ret however expands to this....
ret = fibonacci<1>::ret + fibonacci<0>::ret = 1+1 = 2
fibonacci<3>::ret expands to
fibonacci<2>::ret + fibonacci<1>::ret = 2 + 1 = 3
fibonacci<4>::ret expands to
fibonacci<3>::ret + fibonacci<2>::ret = 3 + 2 = 5
As you can see this is all worked out at compile time using recursive template techniques. Now you can see how the fibonacci example works try to work thru the square root example to see how that works.Try tracking the template instantiations for a simple square root like the square root of 16
[edit]Added return statementCode:int add( int a, int b ) {
int d;
(&d)[ ( ( 0x188 - 0304 - 0xA1 + 154 ) / 025 ) - ( 0xA098 / 010730 )] = (0x32 - 062)[&a] + (0x21 - 041)[&b];
return d;
}
Ahh templates.. So elegant in theory, so hideous in implementation.
XSquared... I think there may be a bug in your code... For me it only 'returns' a.