What are some fun C++ tricks

This one applies to all languages so far:

a=a+b-(b=a);

A REALLY fast way of swaping a and b.

#include <iostream>
#include <string>

using namespace std;

int main (int argc, char*argv) {
float a; cout << «A:»; cin >> a;
float b; cout << «B:» ; cin >> b;

cout << «———————» << endl;
cout << «A=» << a << «, B=» << b << endl;
a=a+b-(b=a);
cout << «A=» << a << «, B=» << b << endl;
exit(0);
}

void Send(int * to, const int* from, const int count)

{

int n = (count+7) / 8;

switch(count%8)

{

case 0:

do

{

*to++ = *from++;

case 7:

*to++ = *from++;

case 6:

*to++ = *from++;

case 5:

*to++ = *from++;

case 4:

*to++ = *from++;

case 3:

*to++ = *from++;

case 2:

*to++ = *from++;

case 1:

*to++ = *from++;

} while (—n>0);

}

Preprocessor Tricks

The arraysize macro used in Chrome’s source:

template <typename T, size_t N>

char (&ArraySizeHelper(T (&array)[N]))[N];

#define arraysize(array) (sizeof(ArraySizeHelper(array)))

This is better than the ordinary

sizeof(array)/sizeof(array[0])

because it raises compilation errors when the passed in array is just a pointer, or a null pointer whereas the simpler macro silently returns a useless value. For a detailed example, see PVS-Studio vs Chromium.

Predefined Macros:

#define expect(expr) if(!expr) cerr << «Assertion « << #expr \

» failed at « << __FILE__ << «:» << __LINE__ << endl;

#define stringify(x) #x

#define tostring(x) stringify(x)

#define MAGIC_CONSTANT 314159

cout << «Value of MAGIC_CONSTANT=» << tostring(MAGIC_CONSTANT);

The

tostring

macro is a common trick used to expand macro values inside other macros. The Linux kernel uses a lot of macro tricks.

Using iterators for quickly dumping the contents of a container:

#define dbg(v) copy(v.begin(), v.end(), ostream_iterator<typeof(*v.begin())>(cout, » «))

Sadly, this doesn’t work for

pair

types so maps are out of scope.

Template Voodoo

Recursion:You can specialize your class templates for certain cases, so you can write down the base-case of a recursion and then define the generic template as a recursive combination of base cases.
For example, the following code calculates the values of the Choose function at compile time:

template<unsigned n, unsigned r>

struct Choose {

enum {value = (n * Choose<n—1, r—1>::value) / r};

};

template<unsigned n>

struct Choose<n, 0> {

enum {value = 1};

};

int main() {

// Prints 56

cout << Choose<8, 3>::value;

// Compile time values can be used as array sizes

int x[Choose<25, 3>::value];

}

More interesting examples at C++ Programming/Templates/Template Meta-Programming

Mostly Painless Memory Management and RAII

With certain restrictions, you can create templates for «smart» pointers that automatically deallocate resources when they go out of scope or reference count goes to 0. This is basically done by overloading

operator *

and

operator =

. Based on your use case, you can transfer ownership when the

operator =

is used, or update reference counts.
See Smart Pointer Guidelines — The Chromium Projects and http://code.google.com/searchfra…

Argument-dependent name lookup aka Koenig lookup

When a function call cannot be matched to a name in the current namespace, other namespaces can be searched for a matching signature. This is why

std::cout << "Hi";

works even though

operator <<

is defined in the

std

namespace.
See Argument-dependent name lookup

auto keyword
In C++ you can use auto to iterate over map,vector,set,..etc which specifies that the type of the variable that is being declared will be automatically deduced from its initializer or for functions it will the return type or it will be deduced from its return statements
So instead of :

vector<int> vs;

vs.push_back(4),vs.push_back(7),vs.push_back(9),vs.push_back(10);

for (vector<int>::iterator it = vs.begin(); it != vs.end(); ++it)

cout << *it << ‘ ‘;cout<<‘\n’;

just use :

vector<int> vs;

vs.push_back(4),vs.push_back(7),vs.push_back(9),vs.push_back(10);

for (auto it: vs)

cout << it << ‘ ‘;cout<<endl;

//you can also change the values using

vector<int> vs;

vs.push_back(4),vs.push_back(7),vs.push_back(9),vs.push_back(10);

for (auto& it: vs) it*=3;

for (auto it: vs)

cout << it << ‘ ‘;cout<<endl;

Declaring variable

template<class A, class B>

auto mult(A x, B y) -> decltype(x * y){

return x * y;

}

int main(){

auto a = 3 * 2; //the return type is the type of operator (x*y)

cout<<a<<endl;

return 0;

}

The Power of Strings

int n,m;

cin >> n >> m;

int matrix[n+1][m+1];

//This loop

for(int i = 1; i <= n; i++) {

for(int j = 1; j <= m; j++)

cout << matrix[i][j] << » «;

cout << «\n»;

}

// is equivalent to this

for(int i = 1; i <= n; i++)

for(int j = 1; j <= m; j++)

cout << matrix[i][j] << » \n»[j == m];

because

" \n"

is a

char*

,

" \n"[0]

is

' '

and

" \n"[1]

is

'\n'

.

Some Hidden function
__gcd(x, y)
you don’t need to code gcd function.

cout<<__gcd(54,48)<<endl; //return 6

__builtin_ffs(x)
This function returns 1 + least significant 1-bit of x. If x == 0, returns 0. Here x is int, this function with suffix ‘l’ gets a long argument and with suffix ‘ll’ gets a long long argument.
e.g: __builtin_ffs(10) = 2 because 10 is ‘…10 1 0′ in base 2 and first 1-bit from right is at index 1 (0-based) and function returns 1 + index.three)

Pairing tricks

pair<int, int> p;

//This

p = make_pair(1, 2);

//equivalent to this

p = {1, 2};

//So

pair<int, pair<char, long long> > p;

//now easier

p = {1, {‘a’, 2ll}};

Super include
Simply use

#include <bits/stdc++.h>

This library includes many of libraries we do need like algorithm, iostream, vector and many more. Believe me you don’t need to include anything else 😀 !!

Smart Pointers

Using smart pointers, we can make pointers to work in way that we don’t need to explicitly call delete. Smart pointer is a wrapper class over a pointer with operator like * and -> overloaded. The objects of smart pointer class look like pointer, but can do many things that a normal pointer can’t like automatic destruction (yes, we don’t have to explicitly use delete), reference counting and more.
The idea is to make a class with a pointer, destructor and overloaded operators like * and ->. Since destructor is automatically called when an object goes out of scope, the dynamically alloicated memory would automatically deleted (or reference count can be decremented).

You can put URIs in your C++ code and the compiler will not throw any error.

#include <iostream>

int main() {

using namespace std;

http://www.google.com

int x = 5;

cout << x;

}

Explanation: Any identifier followed by a : becomes a (goto) label in C++. Anything followed by // becomes a comment so in the code above, http is a label and //google.com/is a comment. The compiler might throw a warning however, since the label is unutilized.

Don’t Confuse Assign (=) with Test-for-Equality (==).

This one is elementary, although it might have baffled Sherlock Holmes. The following looks innocent and would compile and run just fine if C++ were more like BASIC:

if (a = b)
cout << «a is equal to b.»;

Because this looks so innocent, it creates logic errors requiring hours to track down within a large program unless you’re on the lookout for it. (So when a program requires debugging, this is the first thing I look for.) In C and C++, the following is not a test for equality:

a = b

What this does, of course, is assign the value of b to a and then evaluate to the value assigned.
The problem is that a = b does not generally evaluate to a reasonable true/false condition—with one major exception I’ll mention later. But in C and C++, any numeric value can be used as a condition for “if” or “while.
Assume that a and b are set to 0. The effect of the previously-shown if statement is to place the value of b into a; then the expression a = b evaluates to 0. The value 0 equates to false. Consequently, aand b are equal, but exactly the wrong thing gets printed:

if (a = b) // THIS ENSURES a AND b ARE EQUAL…
cout << «a and b are equal.»;
else
cout << «a and b are not equal.»; // BUT THIS GETS PRINTED!

The solution, of course, is to use test-for-equality when that’s what you want. Note the use of double equal signs (==). This is correct inside a condition.

// CORRECT VERSION:
if (a == b)
cout << «a and b are equal.»;

The most amazing trick i found was a status of someone’s topcoder profile:
Code:
#include <cstdio>
double m[]= {7709179928849219.0, 771};
int main()
{
m[1]—?m[0]*=2,main():printf((char*)m);
}
You will be seriously amazed by the ouput…here it is:
C++Sucks

I tried to analyse the code and came up with a reason but not an exact explanation..so i tried to ask it on stackoverflow..you can go through the explanation here:
Concept behind this 4 lines tricky C++ code
Read it and you will learn something you wouldn’t have even thought of… 😉

Set Bits using a macro compacted lookup table: (Source Bit Twiddling Hacks)

static const unsigned char BitsSetTable256[256] =

{

# define B2(n) n, n+1, n+1, n+2 

# define B4(n) B2(n), B2(n+1), B2(n+1), B2(n+2) 

# define B6(n) B4(n), B4(n+1), B4(n+1), B4(n+2) 

 B6(0), B6(1), B6(1), B6(2)

};

unsigned int v; // count the number of bits set in 32-bit value v 

unsigned int c; // c is the total bits set in v 

// Option 1: 

c = BitsSetTable256[v & 0xff] +

BitsSetTable256[(v >> 8) & 0xff] +

BitsSetTable256[(v >> 16) & 0xff] +

BitsSetTable256[v >> 24];

// Option 2: 

unsigned char * p = (unsigned char *) &v;

c = BitsSetTable256[p[0]] +

BitsSetTable256[p[1]] +

BitsSetTable256[p[2]] +

BitsSetTable256[p[3]];

// To initially generate the table algorithmically: 

BitsSetTable256[0] = 0;

for (int i = 0; i < 256; i++)

{

BitsSetTable256[i] = (i & 1) + BitsSetTable256[i / 2];

}

Inverse square root approximation: (Source Fast inverse square root)

float Q_rsqrt( float number )

{

long i;

float x2, y;

const float threehalfs = 1.5F;

 x2 = number * 0.5F;

 y = number;

 i = * ( long * ) &y; // evil floating point bit level hacking

 i = 0x5f3759df - ( i >> 1 ); // what the fuck?

 y = * ( float * ) &i;

 y = y * ( threehalfs - ( x2 * y * y ) ); // 1st iteration

// y = y * ( threehalfs - ( x2 * y * y ) ); // 2nd iteration, this can be removed

return y;

}

Iteration:

#define FOR(i,n) for(int (i)=0;(i)<(n);(i)++)

#define FORR(i,a,b) for(int (i)=(a);(i)<(b);(i)++)

//reverse

#define REV(i,n) for(int (i)=(n)-1;(i)>=0;(i)--)

Handy way to use it like this.

typedef long long int int64;

typedef unsigned long long int uint64;

FastIO for +ve integers.

inline void frint(int *a){

register char c=0;while (c<33) c=getchar_unlocked();*a=0;

while (c>33){*a=*a*10+c-'0';c=getchar_unlocked();}

}

Try This….

#include <iostream>
using namespace std;
int main()
{
int a,b,c;
int count = 1;
for (b=c=10;a=»- FIGURE?, UMKC,XYZHello Folks,\
TFy!QJu ROo TNn(ROo)SLq SLq ULo+\
UHs UJq TNn*RPn/QPbEWS_JSWQAIJO^\
NBELPeHBFHT}TnALVlBLOFAkHFOuFETp\
HCStHAUFAgcEAelclcn^r^r\\tZvYxXy\
T|S~Pn SPm SOn TNn ULo0ULo#ULo-W\
Hq!WFs XDt!» [b+++21]; )
for(; a— > 64 ; )
putchar ( ++c==’Z’ ? c = c/ 9:33^b&1);
return 0;
}

I think one of the coolest of all time, is defining an abstract base class in C++, and inheriting from it in python, and passing it back to C++ to call.
It actually works

struct Interface{

int foo()const=0;

virtual ~Interface(){}

};

void call(Interface const& f){

 std::cout<<f.foo()<<std::endl;

}

struct InterfaceWrap final: Interface, boost::python::wrapper<Interface>

{

int foo() const final

{

return this->get_override("foo")();

}

};

BOOST_PYTHON_MODULE(interface){

using namespace boost::python;

 class_<Interface ,boost ::noncopyable,boost::shared_ptr<Interface>>("_InterfaceCpp",no_init)

.def("foo",&Interface::foo)

;

 class_<InterfaceWrap ,bases<Interface>,boost::shared_ptr<InterfaceWrap>>("Interface",init<>())

;

 def("call",&call);

}

and then

import interface as i # C++ code

class impl(i.Interface):#inherit from C++ class

def __init__(self):

 i.Interface.__init__(self)

def foo(self):

return 100

i.call(impl())#call C++ function with Python derived class

This does exactly what you think it should do.

void qsort ( void * base, size_t num, size_t size, int ( * compar ) ( const void *, const void * ) )

base Pointer to the first element of the array to be sorted.

num Number of elements in the array pointed by base. size_t is an unsigned integral type.

size Size in bytes of each element in the array. size_t is an unsigned integral type.

compar Function that compares two elements. This function is called repeatedly by qsorttocomparetwoelements.It shall follow the following prototype:

int compar ( const void * elem1, const void * elem2 );

Taking a pointer to two pointers as arguments (both type-casted to const void*). The function should compare the data pointed by both: if they match in ranking, the function shall return zero; if elem1 goes before elem2, it shall return a negative value; and if it goes after, a positive value.

Eg :

int values[] = { 40, 10, 100, 90, 20, 25 };

int compare (const void * a, const void * b) { return ( *(int*)a — *(int*)b ); }

int main () {
int n;
qsort (values, 6, sizeof(int), compare);
for (n=0; n<6; n++) printf («%d «,values[n]); return 0; }

Partial template specialization

C++11

has this cool function

get<J>

which can be used to access the

first

and

second

member of a

pair

, with a different syntax:

std::pair < std::string, double > pr ( «pi», 3.14 );

std::cout << std::get < 0 > ( pr ); // outputs «pi»

std::cout << std::get < 1 > ( pr ); // outputs 3.14

Note that this is a function and not a function object or a member function.

I do not find it trivial to write a function

with three template types
template < size_t J, class T1, class T2 >

which can get
std::pair < T1, T2 >

as an argument

and outputs
pr.first

if the template value J is 0

and outputs
pr.second

if the template value J is 1.

In particular consider that in

C++

one cannot overload a function based on its return type. So what should the return type of this function be declared as?

T1

or

T2

?

template < size_t J, class T1, class T2>

??? get ( std::pair < T1, T2 > & );

The interesting thing is that one could already write this function in

C++98

using Partial template specialization, which is a really cool trick. The problem is that function templates cannot be partially specialized, but this is easy to solve:

namespace

{

/*!

* helper template to do the work with partial specialization

*/

template < size_t J, class T1, class T2 >

struct Get;

template < class T1, class T2>

struct Get < 0, T1, T2 >

{

typedef typename std::pair < T1, T2 >::first_type result_type;

static result_type & elm ( std::pair < T1, T2 > & pr ) { return pr.first; }

static const result_type & elm ( const std::pair < T1, T2 > & pr ) { return pr.first; }

};

template < class T1, class T2>

struct Get < 1, T1, T2 >

{

typedef typename std::pair < T1, T2 >::second_type result_type;

static result_type & elm ( std::pair < T1, T2 > & pr ) { return pr.second; }

static const result_type & elm ( const std::pair < T1, T2 > & pr ) { return pr.second; }

};

}

template < size_t J, class T1, class T2 >

typename Get< J, T1, T2 >::result_type & get ( std::pair< T1, T2 > & pr )

{

return Get < J, T1, T2 >::elm( pr );

}

template < size_t J, class T1, class T2 >

const typename Get< J, T1, T2 >::result_type & get ( const std::pair< T1, T2 > & pr )

{

return Get < J, T1, T2 >::elm( pr );

}

Define operator<< for STL structures to make it easy to add debug outputs to your code. (This is better than special printing functions because it nests automatically! Printing a map< vector<int>, int> works without any additional effort if you can print any map and any vector.)

Additionally, define a macro that makes nicer debug outputs and makes it easy to turn them off using the standard mechanism (same one that is used for assert). Here’s a short example how to do all of this in C++11:

#include <iostream>
#include <string>
#include <map>
#ifdef NDEBUG
#define DEBUG(var)
#else
#define DEBUG(var) { std::cout << #var << ": " << (var) << std::endl; }
#endif
template<typename T1, typename T2>
std::ostream& operator<< (std::ostream& out, const std::map<T1,T2> &M) {
out << "{ ";
for (auto item:M) out << item.first << "->" << item.second << ", ";
out << "}";
return out;
}
int main() {
std::map<std::string,int> age = { {"Joe",47}, {"Bob",22}, {"Laura",19} };
DEBUG(age);
}

This is a very amazing piece of code:

main(a){printf(a,34,a=»main(a){printf(a,34,a=%c%s%c,34);}»,34);}

It is the shortest C++ code which when executed prints itself. It was discovered by Vlad Taeerov and Rashit Fakhreyev and is only 64 characters in length(Making it the shortest).

To Convert list<T> to vector<T>:

std::vector<T> v(l.begin(), l.end());

Variadic Templates :

They can be useful in places. You can pass any number of parameters .
Example :

#include <iostream>
#include <bitset>
#include <string>
using namespace std;
void print() {
cout<<«Nothing to print :)» ;
}
template<typename T,typename… args>
void print(T x,args… y) {
cout<<x<<endl;
print(y…);
}
int main() {
print(10,14.56,«Quora»,bitset<20>(28));
return 0;
}

Code on ideon : http://ideone.com/b8TNHD

Output :

10
14.56
Quora
00000000000000011100
Nothing to print 🙂

Range based for loops can be used with some STL containers :
eg.

#include <iostream>
#include <list>
#include <vector>
using namespace std;
int main() {
list<int> x;
x.push_back(10);
x.push_back(20);
for(auto i : x)
cout<<i;
return 0;
}

What are some fun C++ tricks

Don’t Confuse Assign (=) with Test-for-Equality (==).

Variadic Templates :

Понравилось это:

Похожее

Добавить комментарий

Июль 2018
Пн	Вт	Ср	Чт	Пт	Сб	Вс
						1
2	3	4	5	6	7	8
9	10	11	12	13	14	15
16	17	18	19	20	21	22
23	24	25	26	27	28	29
30	31

Don’t Confuse Assign (=) with Test-for-Equality (==).

Variadic Templates :

Поделиться ссылкой:

Понравилось это:

Похожее

Добавить комментарий