Communities

Communities

Total Articles 180

Join
Login

VInt class header file

gilgil

http://www.gilgil.net/?document_srl=15449

2012.04.17 18:57:26 (*.35.13.186)

70565

When you

1. use C++ STL library(list, vector, map, and so on).
2. make your own template library
3. use their objects as global or static

you want to know when the object is created, accessed, deleted and copied.

Here is a good sample class code named "VMyInt"(wrapper class for int primitive type).

Using VMyInt class, you can figure out easily how the object is accessed.

[Source Code]

// ----------------------------------------------------------------------------
//
// vdream Component Suite version 8.0
//
// http://www.gilgil.net
//
// Copyright (c) Gilbert Lee All rights reserved
//
// ----------------------------------------------------------------------------

// http://en.wikipedia.org/wiki/Operators_in_C_and_C%2B%2B

#ifndef __V_INT_H__
#define __V_INT_H__

#include <stdio.h>   // for vsprintf
#include <stdarg.h>  // for va_list
#include <stdlib.h>  // for malloc

#ifdef WIN32
// #pragma warning( disable : 4100 ) // gilgil temp 2012..5.20
#endif // WIN32

// ----------------------------------------------------------------------------
// VInt
// ----------------------------------------------------------------------------
class VInt
{
protected:
  int _i;

public:
  // --------------------------------------------------------------------------
  // Constructor and destructor
  // --------------------------------------------------------------------------
  VInt()                                 { D("%p VInt::VInt()\n",              this);               _i = 0;                                  } // A a      : Default constructor
  VInt(const VInt& b)                    { D("%p VInt::VInt(VInt& %d) %p\n",   this, b._i, &b);     _i = b._i;                               } // A a(b)   : Copy constructor
  VInt(const int i)                      { D("%p VInt::VInt(int %d)\n",        this, i);            _i = i;                                  } // A a(i)   : Conversion constructor
  ~VInt()                                { D("%p VInt::~VInt() %d\n",          this, _i);                                                    } // delete a : Destrutor

  // --------------------------------------------------------------------------
  // Arithmetic operators
  // --------------------------------------------------------------------------
  VInt& operator = (const VInt& b)       { D("%p VInt(%d)::= (VInt& %d) %p\n", this, _i, b._i, &b); _i = b._i;            return *this;      } // a = b : Basic assignment
  VInt  operator + (const VInt& b) const { D("%p VInt(%d)::+ (VInt& %d) %p\n", this, _i, b._i, &b); VInt res(_i + b._i);  return res;        } // a + b : Addition
  VInt  operator - (const VInt& b) const { D("%p VInt(%d)::- (VInt& %d) %p\n", this, _i, b._i, &b); VInt res(_i - b._i);  return res;        } // a - b : Subtraction
  VInt  operator + () const              { D("%p VInt(%d)::+ ()\n",            this, _i);           VInt res(_i);         return res;        } // +a    : Unary plus
  VInt  operator - () const              { D("%p VInt(%d)::- ()\n",            this, _i);           VInt res(-_i);        return res;        } // -a    : Unary minus
  VInt  operator * (const VInt& b) const { D("%p VInt(%d)::* (VInt& %d) %p\n", this, _i, b._i, &b); VInt res(_i * b._i);  return res;        } // a * b : Multiplication
  VInt  operator / (const VInt& b) const { D("%p VInt(%d)::/ (VInt& %d) %p\n", this, _i, b._i, &b); VInt res(_i / b._i);  return res;        } // a / b : Division
  VInt  operator % (const VInt& b) const { D("%p VInt(%d)::% (VInt& %d) %p\n", this, _i, b._i, &b); VInt res(_i % b._i);  return res;        } // a % b : Modulo
  VInt& operator ++()                    { D("%p VInt(%d)::++()\n",            this, _i);           _i++;                 return *this;      } // ++a   : Prefix increment
  VInt  operator ++(int)                 { D("%p VInt(%d)::++(int)\n",         this, _i);           VInt res(_i); _i++;   return res;        } // a++   : Suffix increment
  VInt& operator --()                    { D("%p VInt(%d)::--()\n",            this, _i);           _i--;                 return *this;      } // --a   : Prefix decrement
  VInt  operator --(int)                 { D("%p VInt(%d)::--(int)\n",         this, _i);           VInt res(_i); _i--;   return res;        } // a--   : Suffix decrement

  // --------------------------------------------------------------------------
  // Comparison operators/relational operators
  // --------------------------------------------------------------------------
  bool  operator ==(const VInt& b) const { D("%p VInt(%d)::==(VInt& %d) %p\n", this, _i, b._i, &b);                       return _i == b._i; } // a == b : Equal to
  bool  operator !=(const VInt& b) const { D("%p VInt(%d)::!=(VInt& %d) %p\n", this, _i, b._i, &b);                       return _i != b._i; } // a != b : Not equal to
  bool  operator > (const VInt& b) const { D("%p VInt(%d)::> (VInt& %d) %p\n", this, _i, b._i, &b);                       return _i >  b._i; } // a > b  : Greater than
  bool  operator < (const VInt& b) const { D("%p VInt(%d)::< (VInt& %d) %p\n", this, _i, b._i, &b);                       return _i <  b._i; } // a < b  : Less than
  bool  operator >=(const VInt& b) const { D("%p VInt(%d)::>=(VInt& %d) %p\n", this, _i, b._i, &b);                       return _i >= b._i; } // a >= b : Greater than or equal to
  bool  operator <=(const VInt& b) const { D("%p VInt(%d)::<=(VInt& %d) %p\n", this, _i, b._i, &b);                       return _i <= b._i; } // a <= b : Less than or equal to

  // --------------------------------------------------------------------------
  // Logical operators
  // --------------------------------------------------------------------------
  bool  operator ! () const              { D("%p VInt(%d)::! ()\n",            this, _i);                                 return !_i;        } // !a     : Logical NOT
  bool  operator &&(const VInt& b) const { D("%p VInt(%d)::&&(VInt& %d) %p\n", this, _i, b._i, &b);                       return _i && b._i; } // a && b : Logical AND
  bool  operator ||(const VInt& b) const { D("%p VInt(%d)::||(VInt& %d) %p\n", this, _i, b._i, &b);                       return _i || b._i; } // a || b : Logical OR

  // --------------------------------------------------------------------------
  // Bitwise operators
  // --------------------------------------------------------------------------
  VInt  operator ~ ()              const { D("%p VInt(%d)::~ ()\n",            this, _i);           VInt res(~_i);        return res;        } // ~a     : Bitwise NOT
  VInt  operator & (const VInt& b) const { D("%p VInt(%d)::& (VInt& %d) %p\n", this, _i, b._i, &b); VInt res(_i & b._i);  return res;        } // a & b  : Bitwise AND
  VInt  operator | (const VInt& b) const { D("%p VInt(%d)::| (VInt& %d) %p\n", this, _i, b._i, &b); VInt res(_i | b._i);  return res;        } // a | b  : Bitwise OR
  VInt  operator ^ (const VInt& b) const { D("%p VInt(%d)::^ (VInt& %d) %p\n", this, _i, b._i, &b); VInt res(_i ^ b._i);  return res;        } // a ^ b  : Bitwise XOR
  VInt  operator <<(const VInt& b) const { D("%p VInt(%d)::<<(VInt& %d) %p\n", this, _i, b._i, &b); VInt res(_i << b._i); return res;        } // a << b : Bitwise left shift
  VInt  operator >>(const VInt& b) const { D("%p VInt(%d)::>>(VInt& %d) %p\n", this, _i, b._i, &b); VInt res(_i >> b._i); return res;        } // a >> b : Bitwise right shift

  // --------------------------------------------------------------------------
  // Compound assignment operators
  // --------------------------------------------------------------------------
  VInt& operator +=(const VInt& b)       { D("%p VInt(%d)::+=(VInt& %d) %p\n", this, _i, b._i, &b); _i += b._i;           return *this;      } // a += b  : Addition assignmentf
  VInt& operator -=(const VInt& b)       { D("%p VInt(%d)::-=(VInt& %d) %p\n", this, _i, b._i, &b); _i -= b._i;           return *this;      } // a -= b  : Subtraction assignment
  VInt& operator *=(const VInt& b)       { D("%p VInt(%d)::*=(VInt& %d) %p\n", this, _i, b._i, &b); _i *= b._i;           return *this;      } // a *= b  : Multiplication assignment
  VInt& operator /=(const VInt& b)       { D("%p VInt(%d)::/=(VInt& %d) %p\n", this, _i, b._i, &b); _i /= b._i;           return *this;      } // a /= b  : Division assignment
  VInt& operator %=(const VInt& b)       { D("%p VInt(%d)::%=(VInt& %d) %p\n", this, _i, b._i, &b); _i %= b._i;           return *this;      } // a %= b  : Modulo assignment
  VInt& operator &=(const VInt& b)       { D("%p VInt(%d)::&=(VInt& %d) %p\n", this, _i, b._i, &b); _i &= b._i;           return *this;      } // a &= b  : Bitwise AND assignment
  VInt& operator |=(const VInt& b)       { D("%p VInt(%d)::|=(VInt& %d) %p\n", this, _i, b._i, &b); _i |= b._i;           return *this;      } // a |= b  : Bitwise OR assignment
  VInt& operator ^=(const VInt& b)       { D("%p VInt(%d)::^=(VInt& %d) %p\n", this, _i, b._i, &b); _i ^= b._i;           return *this;      } // a ^= b  : Bitwise XOR assignment
  VInt& operator <<=(const VInt& b)      { D("%p VInt(%d)::<<=(VInt& %d) %p\n", this, _i, b._i, &b); _i <<= b._i;         return *this;      } // a <<= b : Bitwise left shift assignment
  VInt& operator >>=(const VInt& b)      { D("%p VInt(%d)::>>=(VInt& %d) %p\n", this, _i, b._i, &b); _i >>= b._i;         return *this;      } // a >>= b : Bitwise right shift assignment

  // --------------------------------------------------------------------------
  // Member and pointer operators
  // --------------------------------------------------------------------------
  // R&   operator [](const T2& b)                                                                                                             // a[b]  : Array subscript
  // R&   operator *()                                                                                                                         // *a    : Indirection ("object pointed to by a")
  // VInt* operator & ()                    { D("%p VInt(%d)::& ()\n",            this, _i);                                 return this;    } // &a    : Reference ("address of a")
  // R*   operator ->()                                                                                                                        // a->b  : Structure dereference ("member b of object pointed to by a")
  // N/A                                                                                                                                       // a.b   : Structure reference ("member b of object a")
  // R    operator->*(R)                                                                                                                       // a->*b : Member pointed to by b of object pointed to by a
  // N/A                                                                                                                                       // a.*b  : Member pointed to by b of object a

  
  // --------------------------------------------------------------------------
  // Other operators
  // --------------------------------------------------------------------------
  // R    operator ()(Arg1 a1, Arg2 a2, …)                                                                                                     // a(a1, a2)               : Function call
  // R&   operator ,(R& b) const                                                                                                               // a, b                    : Comma
  // N/A                                                                                                                                       // a ? b : c               : Ternary conditional
  // N/A                                                                                                                                       // a::b                    : Scope resolution
  // N/A                                                                                                                                       // sizeof(a), sizeof(A)    : Size-of
  // N/A                                                                                                                                       // alignof(A), _Alignof(A) : Align-of
  // N/A                                                                                                                                       // typeid(a), typeid(A)    : Type identification
  operator int() const                   { D("%p VInt::int(%d)\n",             this, _i);                                 return _i;         } // (type)a                 : Cast
  void* operator new(size_t x)           { void* res = malloc(x); D("%p VInt::new(%d)\n", res, x);                        return res;        } // new A                   : Allocate storage
  void* operator new[](size_t x)         { void* res = malloc(x); D("%p VInt::new[](%d)\n", res, x);                      return res;        } // new A[n]                : Allocate storage (array)
  void  operator delete(void* p)         { D("%p VInt::delete\n",              p);                  free(p);                                 } // delete a                : Deallocate storage
  void  operator delete[](void* p)       { D("%p VInt::delete[]\n",            p);                  free(p);                                 } // delete[] a              : Deallocate storage (array)

public:
#ifdef _DEBUG
  static void D(const char* fmt, ...)
  {
    static const int BUF_SIZE = 4096;
    char  buf[BUF_SIZE];
    va_list args;
    va_start(args, fmt);
    #ifdef __STDC_WANT_SECURE_LIB__
      int len = vsprintf_s(buf, BUF_SIZE, fmt, args);
    #else
      int len = vsprintf(buf, fmt, args);
    #endif // __STDC_WANT_SECURE_LIB__
    if (len != -1) printf("%s", buf);
    va_end(args);
  }
#else // _DEBUG
  static void D(const char* fmt, ...)
  {
    (void)fmt; // Q_UNUSED(fmt);
  }
#endif // _DEBUG
};

#endif // __V_INT_H__

[Download]

~~VMyInt.h~~

vint.h (2013.09.26) : class name changed from VMyInt into VInt.

You would..

List

No.	Subject		Author	Views	Date
100	Class diagram		gilgil	69584	Oct 08, 2013
100	http://en.wikipedia.-org/wiki/Class_diagr-am
99	Fedora installation for Qt		gilgil	69517	Oct 05, 2013
99	Fedora installation Change display Change root login Security Update yum install gcc yum install gcc-c++ yum install make Install Qt(4.8.1) yum install libpng-compat ( for libpng12.so file ) yum install xterm ...
98	url_test for qt		gilgil	69579	Oct 05, 2013
98	[Source] // ---------------------------------------------------------------------------- // // VDream Component Suite version 8.0 // // http://www.gilgil.ne-t // // Copyright (c) Gilbert Lee All rights reserved // // ------------------------...
97	How to use meta class in C++		gilgil	69604	Oct 04, 2013
97	Thers is a base class named "Shape" that has a virtual function "draw()". class Shape { public: virtual void draw() = 0; }; Circle, Triangle, Rectangle and Pentagon classes are descendent classes of Shape class. ...
96	Enumeration type wrapping class in C++ (Days)		gilgil	69641	Sep 30, 2013
96	Here is a sample code of enumeration type wrapping class in C++. [Source Code] #include <stdio.h> class Days { public: enum _Days { Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday }; protected: _...
95	wireshark build on windows		gilgil	66920	May 13, 2013
95	http://www.wireshark-.org/docs/wsdg_html_-chunked/ChSetupWin32-.html
94	malicious site list		gilgil	96181	May 08, 2013
94	http://www.selectrea-lsecurity.com/public--block-lists http://www.malwaredo-mainlist.com/hostsli-st/hosts.txt http://www.malwaredo-mains.com/?page_id=66 http://mirror1.malwa-redomains.com/files/-domains.txt http://mirror1.malwa-redomains.com/files/-...
93	qt-everywhere-4.8.4-configure 1		gilgil	78904	May 03, 2013
93	Unable to detect the platform from environment. Use -platform command lineargument or set the QMAKESPEC environment variable and run configure again See the README file for a list of supported op...
92	gui_option_test		gilgil	69617	Apr 11, 2013
92	[gui_option_test.pro] contains(QT, gui) { message (gui) } else { message (no_gui) } TARGET = gui_option_test CONFIG += console CONFIG -= app_bundle TEMPLATE = app SOURCES += main.cpp [main.cpp]...
91	Talk is cheap. Show me the code.		gilgil	68217	Mar 22, 2013
91	https://lkml.org/lkm-l/2000/8/25/132
90	so_test		gilgil	69572	Feb 22, 2013
90	so_test.zip
89	network layer protocol constants		gilgil	69599	Feb 21, 2013
89	[DataLink Type] : bpf.h #define DLT_NULL 0 /* BSD loopback encapsulation / #define DLT_EN10MB 1 / Ethernet (10Mb) / #define DLT_EN3MB 2 / Experimental Ethernet (3Mb) / #define DLT_AX25 3 / Amateur Radio ...
88	pipe_test		gilgil	69218	Feb 19, 2013
88	pipe_test(2013.02.19-)-2.zip pipe_test(2013.02.19-).zip
87	VDream option for Qt pro file		gilgil	69588	Feb 18, 2013
87	#------------------------------------------------- # Common #------------------------------------------------- CONFIG(release, debug\|release) { DEFINES += _RELEASE D = "" } CONFIG(debug, debug\|release) { DEFINES += _DEBUG D = "d" } LI...
86		A Tour of Go	gilgil	69644	Feb 17, 2013
86		A programming language guide line of Go(open source programming powered by Google) http://tour.golang.o-rg
85	qmake.conf for msvc2008 1		gilgil	69294	Feb 12, 2013
85	# # qmake configuration for win32-msvc2008 # # Written for Microsoft Visual C++ 2008 # MAKEFILE_GENERATOR = MSVC.NET TEMPLATE = app CONFIG += qt warn_on release incremental flat link_prl prec...
84	linux installation guide for virtual machine		gilgil	69546	Jan 19, 2013
84	os installation install ubuntu-14.04.1-desktop-amd64.iso basic setup enable root account #sudo passwd root > <current password> > <root password> > <root password again> add the following line at the end of c...
	VInt class header file		gilgil	70565	Apr 17, 2012
	When you 1. use C++ STL library(list, vector, map, and so on). 2. make your own template library 3. use their objects as global or static you want to know when the object is created, accessed, deleted...
82	How to use property code in C++		gilgil	76059	Apr 05, 2012
82	To enhahce code readibility, C++ programmers sometime prefer property code(getter, setter) to access member function. Here is a sample code. class Person { protected: int m_age; public: __declspec(property (get...
81	Minimal WinMain Source Code		gilgil	2	Mar 08, 2012
81	This article is secret

List

Write

First Page 1 2 3 4 5 6 7 8 9 Last Page

VInt class header file

Home

Downloads

Communities(KR)

Test