The Function Pointer Tutorials
Introduction to C and C++ Function Pointers, Callbacks and Functors
written by Lars Haendel
January 2005, Bochum, Germany
http://www.newty.de
email: Have a look at the web page please
version 2.07

Copyright (c) 2000-2005 by Lars Haendel. Permission is granted to copy,
distribute and/or modify this document under the terms of the GNU Free
Documentation License, Version 1.1 or any later version published by the
Free Software Foundation; with no Invariant Sections, with the Front-
Cover Text being the text from the title up to the table of contents, and
with no Back-Cover Texts. A copy of the license can be obtained from
http://www.gnu.org .
Be aware that there may be a newer version of this document! Check
http://www.newty.de/fpt/zip/e fpt.pdf for the latest release. If you want
to distribute this document, I suggest you to link to the URL above to
prevent spreading of outdated versions.
You may also download the source code of the examples at
http://www.newty.de/fpt/zip/source.zip . The example code is free software
under the terms of the GNU General Public License.

1
1 Introduction to Function Pointers
Function Pointers provide some extremely interesting, efficient and elegant programming techniques. You can
use them to replace switch/if-statements, to realize your own late-binding or to implement callbacks. Unfortunately
– probably due to their complicated syntax – they are treated quite stepmotherly in most computer
books and documentations. If at all, they are addressed quite briefly and superficially. They are less error prone
than normal pointers cause you will never allocate or de-allocate memory with them. All you’ve got to do is
to understand what they are and to learn their syntax. But keep in mind: Always ask yourself if you really
need a function pointer. It’s nice to realize one’s own late-binding but to use the existing structures of C++
may make your code more readable and clear. One aspect in the case of late-binding is runtime: If you call a
virtual function, your program has got to determine which one has got to be called. It does this using a V-Table
containing all the possible functions. This costs some time each call and maybe you can save some time using
function pointers instead of virtual functions. Maybe not ... 1
1.1 What is a Function Pointer ?
Function Pointers are pointers, i.e. variables, which point to the address of a function. You must keep in mind,
that a running program gets a certain space in the main-memory. Both, the executable compiled program code
and the used variables, are put inside this memory. Thus a function in the program code is, like e.g. a character
field, nothing else than an address. It is only important how you, or better your compiler/processor, interpret
the memory a pointer points to.
1.2 Introductory Example or How to Replace a Switch-Statement
When you want to call a function DoIt() at a certain point called label in your program, you just put the call
of the function DoIt() at the point label in your source code. Then you compile your code and every time your
program comes up to the point label, your function is called. Everything is ok. But what can you do, if you
don’t know at build-time which function has got to be called? What do you do, when you want to decide it
at runtime? Maybe you want to use a so called Callback-Function or you want to select one function out of a
pool of possible functions. However you can also solve the latter problem using a switch-statement, where you
call the functions just like you want it, in the different branches. But there’s still another way: Use a function
pointer! In the following example we regard the task to perform one of the four basic arithmetic operations.
The task is first solved using a switch-statement. Then it is shown, how the same can be done using a function
pointer.2
//------------------------------------------------------------------------------------
// 1.2 Introductory Example or How to Replace a Switch-Statement
// Task: Perform one of the four basic arithmetic operations specified by the
// characters ’+’, ’-’, ’*’ or ’/’.
// The four arithmetic operations ... one of these functions is selected
// at runtime with a swicth or a function pointer
float Plus (float a, float b) { return a+b; }
float Minus (float a, float b) { return a-b; }
float Multiply(float a, float b) { return a*b; }
float Divide (float a, float b) { return a/b; }
// Solution with a switch-statement - specifies which operation to execute
void Switch(float a, float b, char opCode)
{
float result;
// execute operation
switch(opCode){
case ’+’ : result = Plus (a, b); break;
case ’-’ : result = Minus (a, b); break;
case ’*’ : result = Multiply (a, b); break;
case ’/’ : result = Divide (a, b); break; }
1Modern compilers are very good! With my Borland Compiler the time I was able to save calling a virtual function which
multiplies two floats was about 2 percent.
2It’s only an example and the task is so easy that I suppose nobody will ever use a function pointer for it ;-)
2
cout << "Switch: 2+5=" <<> is a function pointer and points to
// a function which takes two floats and returns a float. The function pointer
// "specifies" which operation shall be executed.
void Switch_With_Function_Pointer(float a, float b, float (*pt2Func)(float, float))
{
float result = pt2Func(a, b); // call using function pointer
cout << "Switch replaced by function pointer: 2-5="; // display result cout << const =" NULL;" pt2function =" DoIt;" pt2function =" &DoMore;" pt2constmember =" &TMyClass::DoMore;" pt2member =" &TMyClass::DoIt;"> may also legally point to &DoMore
2.4 Comparing Function Pointers
You can use the comparison-operators (==, !=) the same way as usual. In the following example it is checked,
whether pt2Function and pt2Member actually contain the address of the functions DoIt and TMyClass::DoMore.
A text is shown in case of equality.
// 2.4 comparing function pointers
// C
if(pt2Function >0){ // check if initialized
if(pt2Function == &DoIt)
printf("Pointer points to DoIt\n"); }
else
printf("Pointer not initialized!!\n");
// C++
if(pt2ConstMember == &TMyClass::DoMore)
cout << "Pointer points to TMyClass::DoMore" <<>* are used together with an instance of a class in order to call one of their (non-static) member functions. If
the call takes place within another member function you may use the this-pointer.
// 2.5 calling a function using a function pointer
int result1 = pt2Function (12, ’a’, ’b’); // C short way
int result2 = (*pt2Function) (12, ’a’, ’b’); // C
TMyClass instance1;
int result3 = (instance1.*pt2Member)(12, ’a’, ’b’); // C++
int result4 = (*this.*pt2Member)(12, ’a’, ’b’); // C++ if this-pointer can be used
TMyClass* instance2 = new TMyClass;
int result4 = (instance2->*pt2Member)(12, ’a’, ’b’); // C++, instance2 is a pointer
delete instance2;
2.6 How to Pass a Function Pointer as an Argument ?
You can pass a function pointer as a function’s calling argument. You need this for example if you want to pass
a pointer to a callback function. The following code shows how to pass a pointer to a function which returns
an int and takes a float and two char:
//------------------------------------------------------------------------------------
// 2.6 How to Pass a Function Pointer
// is a pointer to a function which returns an int and takes a float and two char
void PassPtr(int (*pt2Func)(float, char, char))
{
int result = (*pt2Func)(12, ’a’, ’b’); // call using function pointer
cout <<>
// specifies which function to return
float (*GetPtr1(const char opCode))(float, float){
if(opCode == ’+’)
return &Plus;
else
return &Minus;} // default if invalid operator was passed
5
// Solution using a typedef: Define a pointer to a function which is taking
// two floats and returns a float
typedef float(*pt2Func)(float, float);
// Function takes a char and returns a function pointer which is defined
// with the typedef above. specifies which function to return
pt2Func GetPtr2(const char opCode)
{
if(opCode == ’+’)
return &Plus;
else
return &Minus; // default if invalid operator was passed
}
// Execute example code
void Return_A_Function_Pointer()
{
cout << pt2function="GetPtr1(’+’);" pt2function="GetPtr2(’-’);"> and are arrays
// with 10 pointers to functions which return an int and take a float and two char
// first way using the typedef
pt2Function funcArr1[10] = {NULL};
// 2nd way directly defining the array
int (*funcArr2[10])(float, char, char) = {NULL};
6
// assign the function’s address - ’DoIt’ and ’DoMore’ are suitable functions
// like defined above in 2.1-4
funcArr1[0] = funcArr2[1] = &DoIt;
funcArr1[1] = funcArr2[0] = &DoMore;
/* more assignments */
// calling a function using an index to address the function pointer
printf("%d\n", funcArr1[1](12, ’a’, ’b’)); // short form
printf("%d\n", (*funcArr1[0])(12, ’a’, ’b’)); // "correct" way of calling
printf("%d\n", (*funcArr2[1])(56, ’a’, ’b’));
printf("%d\n", (*funcArr2[0])(34, ’a’, ’b’));
}
// C++ -------------------------------------------------------------------------------
// type-definition: ’pt2Member’ now can be used as type
typedef int (TMyClass::*pt2Member)(float, char, char);
// illustrate how to work with an array of member function pointers
void Array_Of_Member_Function_Pointers()
{
cout <<> and are
// arrays with 10 pointers to member functions which return an int and take
// a float and two char
// first way using the typedef
pt2Member funcArr1[10] = {NULL};
// 2nd way of directly defining the array
int (TMyClass::*funcArr2[10])(float, char, char) = {NULL};
// assign the function’s address - ’DoIt’ and ’DoMore’ are suitable member
// functions of class TMyClass like defined above in 2.1-4
funcArr1[0] = funcArr2[1] = &TMyClass::DoIt;
funcArr1[1] = funcArr2[0] = &TMyClass::DoMore;
/* more assignments */
// calling a function using an index to address the member function pointer
// note: an instance of TMyClass is needed to call the member functions
TMyClass instance;
cout << (instance.*funcArr1[1])(12, ’a’, ’b’) << bigger="cmpFunc(item1,"> // due to: qsort
#include // randomize
#include // printf
// comparison-function for the sort-algorithm
// two items are taken by void-pointer, converted and compared
int CmpFunc(const void* _a, const void* _b)
{
// you’ve got to explicitly cast to the correct type
const float* a = (const float*) _a;
const float* b = (const float*) _b;
if(*a > *b) return 1; // first item is bigger than the second one -> return 1
else
if(*a == *b) return 0; // equality -> return 0
else return -1; // second item is bigger than the first one -> return -1
}
// example for the use of qsort()
void QSortExample()
{
float field[100];
::randomize(); // initialize random-number-generator
for(int c=0;c<100;c++) c="0;c<10;c++)"> // due to: cout
class TClassA
{
public:
void Display(const char* text) { cout << myself =" (TClassA*)">Display(string);
}
// function does something which implies a callback
// note: of course this function can also be a member function
void DoItA(void* pt2Object, void (*pt2Function)(void* pt2Object, char* text))
{
/* do something */
pt2Function(pt2Object, "hi, i’m calling back using a argument ;-)"); // make callback
}
// execute example code
void Callback_Using_Argument()
{
// 1. instantiate object of TClassA
TClassA objA;
// 2. call ’DoItA’ for
DoItA((void*) &objA, TClassA::Wrapper_To_Call_Display);
}
Example B: Pointer to a class instance is stored in a global variable The function DoItB does
something with objects of the class TClassB which implies a callback. A pointer to the static wrapper function
TClassB::Wrapper To Call Display is passed to DoItB. This wrapper is the callback-function. The wrapper
uses the global variable void* pt2Object and explicitly casts it to an instance of TClassB. It is very important,
that you always initialize the global variable to point to the correct class instance. You can write arbitrary other
classes like TClassB and use them with DoItB as long as these other classes provide the necessary functions.
Note: This solution may be useful if you have an existing callback interface which cannot be changed. It is
not a good solution because the use of a global variable is very dangerous and could cause serious errors.
//-----------------------------------------------------------------------------------------
// 3.5 Example B: Callback to member function using a global variable
// Task: The function ’DoItB’ makes something which implies a callback to
// the member function ’Display’. Therefore the wrapper function
// ’Wrapper_To_Call_Display is used.
#include // due to: cout
void* pt2Object; // global variable which points to an arbitrary object
class TClassB
{
public:
void Display(const char* text) { cout <<> to a pointer to TClassB
// warning: MUST point to an appropriate object!
TClassB* mySelf = (TClassB*) pt2Object;
// call member
mySelf->Display(string);
}
// function does something which implies a callback
// note: of course this function can also be a member function
void DoItB(void (*pt2Function)(char* text))
{
/* do something */
pt2Function("hi, i’m calling back using a global ;-)"); // make callback
}
// execute example code
void Callback_Using_Global()
{
// 1. instantiate object of TClassB
TClassB objB;
// 2. assign global variable which is used in the static wrapper function
// important: never forget to do this!!
pt2Object = (void*) &objB;
// 3. call ’DoItB’ for
DoItB(TClassB::Wrapper_To_Call_Display);
}
4 Functors to encapsulate C and C++ Function Pointers
4.1 What are Functors ?
Functors are functions with a state. In C++ you can realize them as a class with one or more private members
to store the state and with an overloaded operator6 () to execute the function. Functors can encapsulate C and
C++ function pointers employing the concepts templates and polymorphism. You can build up a list of pointers
to member functions of arbitrary classes and call them all through the same interface without bothering about
their class or the need of a pointer to an instance. All the functions just have got to have the same returntype
and calling parameters. Sometimes Functors are also known as Closures. You can also use Functors to
implement callbacks.
4.2 How to Implement Functors ?
First you need a base class TFunctor which provides a virtual function named Call or a virtually overloaded
operator () with which you will be able to call the member function. It’s up to you if you prefer the overloaded
operator or a function like Call. From the base class you derive a template class TSpecificFunctor which
is initialized with a pointer to an object and a pointer to a member function in its constructor. The derived
class overrides the function Call and/or the operator () of the base class: In the overrided versions
it calls the member function using the stored pointers to the object and to the member function.
6If you prefer you can also use a function called Execute or something like that.
11
//-----------------------------------------------------------------------------------------
// 4.2 How to Implement Functors
// abstract base class
class TFunctor
{
public:
// two possible functions to call member function. virtual cause derived
// classes will use a pointer to an object and a pointer to a member function
// to make the function call
virtual void operator()(const char* string)=0; // call using operator
virtual void Call(const char* string)=0; // call using function
};
// derived template class
template class TSpecificFunctor : public TFunctor
{
private:
void (TClass::*fpt)(const char*); // pointer to member function
TClass* pt2Object; // pointer to object
public:
// constructor - takes pointer to an object and pointer to a member and stores
// them in two private variables
TSpecificFunctor(TClass* _pt2Object, void(TClass::*_fpt)(const char*))
{ pt2Object = _pt2Object; fpt=_fpt; };
// override operator "()"
virtual void operator()(const char* string)
{ (*pt2Object.*fpt)(string);}; // execute member function
// override function "Call"
virtual void Call(const char* string)
{ (*pt2Object.*fpt)(string);}; // execute member function
};
4.3 Example of How to Use Functors
In the following example we have two dummy classes which provide a function called Display which returns
nothing (void) and needs a string (const char*) to be passed. We create an array with two pointers to TFunctor
and initialize the array entries with two pointers to TSpecificFunctor which encapsulate the pointer to an
object and the pointer to a member of TClassA respectively TClassB. Then we use the functor-array to call
the respective member functions. No pointer to an object is needed to make the function calls and
you do not have to bother about the classes anymore!
//-----------------------------------------------------------------------------------------
// 4.3 Example of How to Use Functors
// dummy class A
class TClassA{
public:
TClassA(){};
void Display(const char* text) { cout <<> specFuncA(&objA, TClassA::Display);
// b) functor which encapsulates pointer to object and to member of TClassB
TSpecificFunctor specFuncB(&objB, &TClassB::Display);
// 3. make array with pointers to TFunctor, the base class, and initialize it
TFunctor* vTable[] = { &specFuncA, &specFuncB };
// 4. use array to call member functions without the need of an object
vTable[0]->Call("TClassA::Display called!"); // via function "Call"
(*vTable[1]) ("TClassB::Display called!"); // via operator "()"
cout << endl << "Hit Enter to terminate!" << endl;
cin.get();
return 0;
}
13

Manusia bahagia bila

Manusia Bahagia Bila....


Manusia bahagia bila ia bisa membuka mata. Untuk menyadari bahwa ia memiliki banyak hal yang berarti. Manusia bisa bahagia bila ia mau membuka mata hati. Untuk menyadari, betapa ia dicintai.Manusia bisa bahagia, bila ia mau membuka diri. Agar orang lain bisa mencintainya dengan tulus.

Manusia tidak bahagia karena tidak mau membuka hati, berusaha meraih yang tidak dapat diraih, memaksa untuk mendapatkan segala yang diinginkan, tidak mau menerima dan mensyukuri yang ada. Manusia buta karena egois dan hanya memikirkan diri, tidak sadar bahwa ia begitu dicintai, tidak sadar bahwa saat ini, apa yang ada adalah baik, selalu berusaha meraih lebih, dan tidak mau sadar karena serakah.

Ada teman yang begitu mencintai, namun tidak diindahkan, karena memilih, menilai dan menghakimi sendiri. Memilih teman dan mencari-cari, padahal di depan mata ada teman yang sejati. Telah memiliki segala yang terbaik, namun serakah, ingin dirinya yang paling diperhatikan, paling disayang, selalu menjadi pusat perhatian, selalu dinomorsatukan. Padahal, semua manusia memiliki peranan, hebat dan nomor satu dalam satu hal, belum tentu dalam hal lain, dicintai oleh satu orang belum tentu oleh orang lain.

Kebahagiaan bersumber dari dalam diri kita sendiri. Jikalau berharap dari orang lain, maka bersiaplah untuk ditinggalkan,
bersiaplah untuk dikhianati. Kita akan bahagia bila kita bisa menerima diri apa adanya, mencintai dan menghargai diri sendiri,
mau mencintai orang lain, dan mau menerima orang lain.

Percayalah kepada Tuhan, dan bersyukurlah kepada-Nya, bahwa kita selalu diberikan yang terbaik sesuai usaha kita, tak perlu berkeras hati. Ia akan memberi kita di saat yang tepat apa yang kita butuhkan, meskipun bukan hari ini, masih ada esok hari. Berusaha dan bahagialah karena kita dicintai begitu banyak orang.

***************************************************************
Tahukah Anda.

Di tahun 1823, Richard Dodd meminjam buku tentang penyakit Febrile dari perpustakaan University of Cincinnati Medical
Library. Entah karena apa, buku terlupakan baik oleh Richard Dodd ataupun oleh pengurus perpustakaan. Dan waktupun terus
berlalu.

Tanggal 7 Desember 1968, cucu dari Richard Dodd mengembalikan buku itu ke perpustakaan Universitas Cincinnati. Buku yang terlambat dikembalikan selama 145 tahun itu seharusnya dikenakan denda sebesar $ 2.264, namun pengelola perpustakaan menghapus denda itu.

***************************************************************
Kata Bijak Hari Ini.

Bila rahasia sebuah atom dari atom-atom tersingkap, rahasia segala benda ciptaan, baik lahir maupun batin akan tersingkap, dan kau takkan melihat pada dunia ini atau dunia yang akan datang sesuatu kecuali Tuhan. (Syaikh Ahmad Al-Alawi).

Tujuh Kiat Sukses

Orang sukses adalah orang yang terus mencoba, meskipun telah mengalami banyak kegagalan. Ia memandang kehidupan sebagai peluang untuk mencapai kesuksesan. Itulah kira-kira kesimpulan dari penelitian selama 40 tahun terhadap orang-orang sukses. Yang dicoba ditemukan dari mereka adalah bagaimana dan mengapa mereka tergerak untuk menjadi teratas di bidang masing masing, dari olah raga, pendidikan, hingga pasar modal.

Apa sebenarnya yang mereka ketahui dan lakukan untuk menjadi sukses?
Berikut ada tujuh hal yang dilakukan mereka dalam meraih sukses:

1. Orang sukses mau mengambil risiko. Mereka berupaya untuk mencapai target, melakukan penghematan, membangun relasi dengan banyak orang, dan gesit mencoba sesuatu yang baru guna mengikuti perkembangan zaman. David C. McClelland, seorang guru besar yang mendalami perjalanan orang-orang sukses serta telah melakukan perjalanan ke banyak negara dan melatih pengusaha kecil, menyatakan cara menjadi pengusaha kecil sukses adalah dengan menjadi pengambil risiko moderat; yang mau terus mengambil risiko untuk meraih sukses.

2. Orang sukses percaya diri dan merasakan bahwa mereka berbuat sesuatu untuk dunia. Mereka memandang sebuah dunia yang besar dan ingin memainkan peranan penting di dalamnya. Mereka tetap bekerja sesuai keterampilan mereka, sambil tetap menyadari bahwa keterampilan inti memberi nilai kepada keterampilan lainnya. Mereka juga sadar, karya terbaik akan menghasilkan kompensasi bagi mereka.

3. Orang sukses menikmati apa yang sedang mereka lakukan. Mereka mampu melihat pekerjaan sebagai kesenangan; mereka memilih bekerja di mana mereka dapat unggul. Orang sukses menyukai tantangan; mereka menikmati pencapaian puncak permainan mereka, apakah di pekerjaan, lapangan tenis atau lapangan golf.

4. Orang sukses adalah pelajar seumur hidup. Mereka menyadari, pendidikan tak pernah berakhir tapi dimulai di setiap tingkatan kehidupan dan terus berlanjut hingga akhir kehidupan. Pendidikan tidak terbatas di ruang kelas; artinya mencoba ide baru, membaca buku, surat kabar, majalah, dan menggunakan Internet merupakan bentuk pendidikan pula. Karena itu, tetaplah mengalir sesuai perubahan ketertarikan dan kemampuan Anda, dan nikmati perubahan. Ini akan membantu Anda tumbuh dan merasakan lebih percaya diri.

5. Orang sukses berpandangan positif terhadap apa yang dapat mereka kerjakan, dan ini meluas pada hal-hal lain. Mereka percaya gelas itu setengah penuh dan bukan setengah kosong. Mereka menanamkan semangat pada diri sendiri dan dapat membayangkan diri bagaimana mereka berhasil menyelesaikan suatu tugas sulit atau mencapai penghargaan tertinggi. Orang sukses berbuat bagaikan pelatih bagi orang lain, dengan menyuguhkan pesan-pesan positif dalam kehidupan sehari-hari. Mereka senang melihat orang lain membuat tonggak sejarah dalam kehidupan mereka.

6. Orang sukses punya banyak cara untuk memotivasi diri sendiri sehingga dapat terus berkarya lebih baik dari yang lain. Ada yang dengan cara melakukan beberapa pekerjaan setiap hari pada bidang berbeda. Seorang pria setengah baya memotivasi dirinya sendiri dengan mencoba mendapatkan lebih banyak uang daripada kakaknya. Seorang wanita berusia 29 tahun menjadi perawat top untuk menunjukkan kepada bekas gurunya bahwa dia memiliki keterampilan dan kecerdasan memadai untuk mencapai profesi itu.

7. Orang sukses menyelesaikan tugas tidak dengan setengah-setengah, dan mereka menggunakan cara kreatif dalam meraih sukses. Meski mungkin membutuhkan waktu lebih lama, mereka akhirnya melampaui garis finis. Mereka manfaatkan waktu dengan baik dalam mensinergikan kemampuan fisik dan mental untuk mencapai sukses.

Rasanya, Anda bisa juga mencoba. Siapa tahu Anda pun mampu mengikuti
jejak mereka. (WWM/William J. Bond/Gde)






Nah sebenarnya apa sih kiat sukses seorang Fadel Muhammad sehingga menjadi konglomerat sukses saat ini ?

Kiatnya menurut Fadel adalah :

1. Kita harus bekerja cerdas, bukan bekerja keras. Bekerja cerdas artinya bekerja dengan menggunakan akal, otak yang lebih banyak. Bukan bekerja siang dan malam tanpa henti. Fadel mengumpamakan, meskipun kita tiap hari main golf tidak ada masalah. Yang penting, akal jalan. Tinggal memandu, angkat telepon, perintah begini-begini, jalan..! Itulah bekerja cerdas.

2. Kita harus Opportunity Oriented, jangan diawalnya sudah risk oriented. Opportunity Oriented seperti misalkan “Nah ini adalah kesempatan baik", bukan risk oriented seperti : “Ini nanti bagaimana ya ?", “Wah jangan gini ah", “Ini bahaya", “Ini begini", “Ini begitu".
Fadel Muhammad ketika masa kuliahnya hampir selesai dulu di benaknya bukan, “Nanti kalau sudah lulus bekerja dimana ya ?". Ini adalah paradigma lama. Kita harus punya paradigma baru dalam hidup, yaitu “Ada kesempatan apa di luar ?". Jadi, Opportunity oriented.

Jadi dua hal diatas yang selalu ada di dalam diri Fadel Muhammad waktu kuliah di saat awal-awal merintis bisnisnya.

Sekedar catatan bahwa Fadel Muhammad hanyalah anak seorang keluarga sederhana dari ayah gorontalo dan ibu ternate.



KIAT SUKSES BERKENALAN

Banyak orang punya masalah ketika berkenalan dengan orang lain. Bagaimana cara memperkenalkan diri, membuat orang lain merasa tertarik pada kita dan selanjutnya bersedia membina hubungan dengan kita? Beberapa tips di bawah mungkin bisa Anda coba:

1. Ketika Anda memutuskan berkenalan dengan seseorang, konsentrasikan diri untuk menarik simpati orang tersebut dengan tutur kata dan suara yang baik, senyuman, bahasa tubuh, etika yang tepat, dan lain-lain. Tampillah sebagai pribadi yang menarik, karena pribadi yang menyenangkan membuat orang lain senang berhubungan dengan Anda.

2. Jika Anda yang menginginkan orang mau berkenalan dengan Anda, fokuskan perhatian pada orang tersebut. Sebelum mulai berkenalan, ketahui apa yang membuat orang tersebut tertarik. Anda bisa mencari tahu dari teman, keluarga atau dari pandangan sekilas berkaitan dengan penampilan, gaya, sikapnya, dan sebagainya.

3. Biasanya, orang tertarik karena adanya kedekatan geografis. Semakin berdekatan orang secara geografis, semakin besar kecenderungan mereka untuk tertarik satu sama lain. Misalnya, dua orang berasal dari Bandung, pembahasan tentang hal-hal di kota Bandung (tempat jalan-jalan, makanan, udara, produk, dan sebagainya) akan menyenangkan.

4. Orang tertarik bila orang lain punya minat serupa. Ahli menemukan bukti kuat bahwa pemilihan pasangan hidup didasarkan atas kemiripan usia, pendidikan, latar belakang etnik (ras, agama). Juga kemiripan sikap, pendapat dan pandangan dunia. Hal yang juga mempengaruhi perasaan seseorang terhadap orang lain adalah kepribadian, gaya berbusana, tingkat sosio-ekonomi, agama, usia, status.

5. Tunjukkan rasa suka pada orang tersebut, karena orang yang Anda sukai cenderung membalas dengan menyukai orang yang menyukainya.

6. Setelah Anda memutuskan topik yang akan Anda angkat untuk memulai pembicaraan, putuskan juga kesan yang ingin Anda buat. Misalnya, dalam situasi bisnis yang normal, kesan terlalu nyantai sementara Anda diharapkan tampak profesional, akan dipersepsi negatif oleh lawan bicara Anda. Orang lain tidak tahu yang ada dalam hati dan pikiran kita, orang hanya tahu orang lain dari apa yang dia lihat atau dengar. Jadi, berhati-hatilah dengan ekspresi, suara, gerak tubuh.

7. Jaga sikap tubuh. Kontak mata langsung sangat baik karena tatapan terang-terangan dipersepsi positif. Berlatihlah menatap langsung dengan ramah, respek, percaya diri dan meyakinkan. Tunjukkan minat tulus dan jujur melalui mata ketika berbicara. Hadapkan kepala Anda pada orang yang diajak berbicara. Jangan menatap orang dengan melirik, karena itu tidak mencerminkan ketulusan.

8. Ketika berjabat tangan, tunjukkan kesan respek, hangat, dan percaya diri. Berlatihlah jabat tangan yang baik dan mengesankan. Hindari jabat tangan yang sangat kencang atau jabat tangan dingin seperti ikan basah karena mengesankan 'saya tidak tertarik pada Anda'.

9. Pada perkenalan pihak ketiga, yang muda diperkenalkan lebih dahulu pada yang lebih tua, yang lebih tinggi jabatannya atau pada wanita (dalam kehidupan sosial).

10. Jadilah pendengar yang baik. Belajar untuk ingin mendengarkan kata-katanya. Tidak ada topik yang tidak menarik, kita saja yang tidak tertarik. Berempatilah pada isi ceritanya.

11. Berkaitan dengan gelar, sebaiknya lupakan gelar sendiri, artinya tidak usah menyebutu diri sebagai Ir. Toni atau Bapak Toni, namun cukup Toni.

12. Perhatikan penyebutan nama. Sebut nama orang tersebut di awal perkenalan. Misalnya, "Senang bertemu Anda, Bu Novi." Bila nama orang tersebut kurang jelas, minta penegasan sekali lagi. Ketika orang tersebut memberi kartu nama, minta nama dieja sehingga tidak keliru. Hal ini positif, karena orang akan merasa terkesan pada usaha maksimal kita menyebut namanya.

13. Beri pujian pada namanya. Mengatakan namanya indah, jarang dimiliki orang atau amat pantas dengan pembawaannya. Ini membuat orang merasa tersanjung, selain juga membantu kita mempermudah mengingat namanya.

Kiriman: Leila Mona Ganiem, S.Pd, M.Si - Konsultan Komunikasi


Kiat Sukses Membangun Kepercayaan Diri

Banyak ahli menilai, percaya diri merupakan faktor penting yang menimbulkan perbedaan besar antara sukses dan gagal. Karenanya, tidak sedikit pula yang memberikan pandangannya mengenai teknik-teknik membangkitkan rasa percaya diri.


Dalam dimensi yang sangat luas, sukses adalah milik semua orang. Tetapi, tidak semua orang tahu bagaimana cara mendapatkan atau meraih kesuksesan. Kebanyakan orang menilai bahwa kesuksesan adalah milik orang-orang yang ber-IQ tinggi, lulusan sekolah terbaik dan memilih spesialisasi yang paling terkenal.

Penilaian ini memang tidak sepenuhnya salah, tetapi kita juga harus melihat fenomena yang lebih luas, bahwa tidak sedikit orang-orang sukses yang tidak mengenyam pendidikan tinggi. Dengan kata lain, IQ tinggi, lulusan sekolah terbaik dan spesialisasi yang terkenal hanyalah bagian dari penunjang kesuksesan.

Di luar kemampuan itu, ada faktor lain yang tidak kalah pentingnya dalam memprediksi kesuksesan seseorang; itulah yang kita sebut, antusiasme, hasrat, ketekunan, kerja keras, serta kebulatan tekad seumur hidup yang dimilikinya.

Sebagian pakar menilai bahwa untuk mencapai sukses, kematangan pribadi seseorang sangat dibutuhkan. Sebab kematangan pribadi akan mengantarkan seseorang pada sikap optimis dan kesadaran bahwa apa yang dicita-citakannya akan mudah diraih.

Di sisi lain, meraih kesuksesan jelas bukanlah perkara gampang. Ketika kita berusaha untuk meraih apa yang kita inginkan, tentu banyak tantangan yang harus dihadapi. Ada kalanya seseorang begitu tegar, tetapi tidak sedikit juga yang patah semangat bahkan menyerah karena merasa tidak sanggup menghadapi tantangan yang ada di depannya.

Pada saat semacam inilah, rasa percaya diri sangat penting ditumbuhkan. Banyak ahli menilai bahwa percaya diri merupakan faktor penting yang menimbulkan perbedaan besar antara sukses dan gagal. Karenanya, tidak sedikit pula yang memberikan pandangannya mengenai teknik-teknik membangkitkan rasa percaya diri. Berikut ini adalah beberapa kiat guna membangun percaya diri.

Pertama, berani menerima tanggung jawab. Gerald Kushel, Ed.D., direktur The Institute of Effective Thinking, pernah mengadakan penelitian terhadap sejumlah manajer. Dari penelitian tersebut, Kushel menyimpulkan bahwa ia menemukan sifat terpenting yang dimiliki oleh hampir semua manajer yang memiliki kinerja tinggi.

Dan sifat tersebut adalah rasa tanggung jawab yang mendorong mereka untuk tampil "sempurna" tanpa peduli pada hambatan apapun yang menghadangnya. Sebaliknya, manajer yang berkinerja buruk dan gagal mencapai kapasitas maksimumnya cenderung melimpahkan kesalahannya pada siapa saja.

Kedua, kembangkan nilai positif. Jalan menuju kepercayaan diri akan semakin cepat manakala kita mengembangkan nilai-nilai positif pada diri sendiri. Menurut psikolog Robert Anthony, PhD., salah satu cara untuk mengembangkan nilai-nilai positif adalah dengan menghilangkan ungkapan-ungkapan yang mematikan dan menggantinya dengan ungkapan-ungkapan kreatif. Dia menganjurkan membuat peralihan bahasa yang sederhana tapi efektif dari pernyataan negatif ke pernyataan positif. Misalnya, mengganti kata, "Saya tidak bisa," menjadi, "Saya bisa!"

Ketiga, bacalah potensi diri. Segeralah lacak, gali, dan eksplorasi potensi sukses yang ada pada diri kita. Misalnya dengan bertanya kepada orang-orang terdekat. Termasuk juga mengikuti psikotes dan mendatangi para ahli seperti psikiater, dokter bahkan kiai untuk melacak potensi kita. Karena bisa jadi sangat banyak potensi yang kita miliki tanpa kita sadari, sehingga tidak berhasil kita gali.

Keempat, berani mengambil risiko. Keberanian dalam mengambil risiko ini penting, sebab daripada menyerah pada rasa takut alangkah lebih baik belajar mengambil risiko yang masuk akal. Cobalah menerima tantangan, kendati terasa menakutkan atau menciutkan hati. Cari dukungan sebanyak mungkin.

Dengan melakukan hal ini, kita akan mendapat banyak peluang yang tak ternilai harganya. Namun jangan lupa, ketika mencoba sesuatu kita harus siap dengan hasil yang sesuai atau tidak sesuai dengan keinginan.

Kalau hasilnya tak sesuai dengan keinginan, bisa jadi itulah yang terbaik menurut Allah Azza wa Jalla. Kalau kita sudah mencoba, maka niatnya saja sudah menjadi amal. Orang yang gagal adalah orang yang tak pernah berani mencoba. Bukankah menaiki anak tangga kelima puluh harus diawali dengan tangga pertama?

Kelima, tolaklah saran negatif. Bisa jadi, tidak semua orang di sekitar kita memberikan dorongan, dukungan, dan bersikap positif pada kita. Sebagian dari orang yang ada di sekitar kita mungkin berpikiran negatif. Hal inilah yang tak jarang malah melunturkan rasa percaya diri kita dengan mempertanyakan kemampuan, pengalaman, dan aspirasi-aspirasi kita.

Dengan demikian, mungkin ada baiknya jika kita sedikit mengambil jarak dengan sebijak mungkin bila ada pihak-pihak yang mencoba melunturkan kepercayaan diri kita. Keenam, ikuti saran positif. Rasa percaya diri merupakan sifat "menular". Artinya, jika kita dikelilingi oleh orang-orang yang memiliki cara pandang positif, bersemangat, optimis, dsb, maka kita memiliki kecenderungan untuk meniru sifat tersebut.

Karena itu, carilah lingkungan yang bisa memotivasi kita untuk sukses. Kita harus mulai senang bergaul dengan orang-orang yang mempunyai kemampuan untuk bangkit. Bergaul dengan orang-orang yang percaya diri akan berbeda dibandingkan bergaul dengan orang-orang yang gagal. Sebab bergaul dengan orang-orang yang percaya diri, Insya Allah semangatnya akan menular kepada diri kita.

Ketujuh, jadikan keresahan sebagai kawan. Banyak peristiwa atau saat-saat dalam kehidupan yang dapat membuat kita mengalami rasa cemas atau gelisah. Akibatnya, kita mengalami krisis percaya diri. Saat itulah kita harus mulai mengingatkan diri sendiri bahwa rasa cemas dan gelisah merupakan kawan. Tingkatkan energi, tajamkan kecerdasan, tinggikan kewaspadaan, dan kembangkan pancaindera. Daripada menyia-nyiakan energi untuk kecemasan yang sia-sia, lebih baik menghadapi tantangan itu secara tegas dan efektif.

Sesudah perhitungan kita matang, selanjutnya kepercayaan diri akan bertambah dengan memperkokoh ibadah dan doa, karena doa dan ibadah dapat mengundang pertolongan Allah. Semakin kokoh ibadah kita, shalat kita, makin kuat doa-doa kita, dan keyakinan kita dengan pertolongan Allah, maka itu bisa meningkatkan percaya diri.

Kita harus benar-benar menyadari bahwa Allah menciptakan kita benar-benar dengan perhitungan dan pertimbangan Yang Mahacermat. Seperti di firmankan Allah SWT dalam Quran surat at-Tiin ayat 4, "La qad khalaqnal insaana fii ahsani taqwiim" (Sungguh Kami telah menciptakan manusia dalam bentuk yang sebaik-baiknya). Wallahu a`lam.n deny riana/mqp