tmljs1988的专栏

templateclass A{public: typedef T A::*unspecified_bool_type;//另一类型,指向T的指针,但该类型是属于A的,声明时要加A::,访问时应加a..   operator unspecified_bool_type() const  {   m_p= 3;  return &A::m_p;//一定要用A:: }public: T m_p;};A a;A::unspecified_bool_type m= a;//或者A::unspecified_bool

#include#include usingnamespace std; class A{}; class B:public A{}; void F( B& b){    cout"F( B& b)"}void F( A& a){    c

(1)指针数组: 是数组,但数组中的每个元素都是指针int *p[5];//如p[2]是指针,可*p[ 2]=3;(2)指向数组的指针: 是个指针,但它指向的是一个数组int a[5];int (*p)[5];//与前一行比较,*p相当于a,即p=&a;就像:int m;int *pm;//*pm就相当于m.pm=&m;p= &a;//可与前一行合并为int (*p)[5]=&

数据结构与算法 面向对象的C++设计模式 源代码  http://www.brpreiss.com/books/opus4/

C++头文件相互#include时最好是:(1)在"CA.h"中 #include "CB.h". (2)在"CB.h"中用类的前向声明: class CA;(3)最好加上头文件卫士( #ifndef ***  #define ***  #endif)示例如下:(1)"CA.h":#ifndef HEADER_CA#define HEADER_CA

二叉排序树的查找，如找不到某个值，则记录其父结点：Node* Search( Node* root, int key, Node* &prnt){  Node* p= root;  while ( p != NULL)  {    if ( p->data == key)    {      return p;    }    prnt= p;//记录其父结

#include #include  using namespace std; class A{}; class B: public A{}; void F( B& b){    cout"F( B& b)"}void F( A& a){    cout"F( A& a)"<< endl;  } int

osg::ref_ptr model;NodeVisitor vv( TRAVERSE_ALL_CHILDREN);   model->accept( vv);假设model的模型结构如图：则model->accept( vv);多态，相当于调用Group::accept(NodeVisitor)。注意，我开始误认为Group没有对accept()进行重写，但后来在遍历

智能指针只是对指针添加引一个引用计数(_refCount).当new一个对象(即将对象赋予ref_ptr变量指向其它的对象或者将其释放(超出其生命范围,如局部变量)时,执行Referenced::unref(),_refCount会减1,此时如果_refCount为0表明此对象已经没有引用,可删除,delete this;会调用析构函数~Referenced(),并释放内存资源.

多态时最好将基类的析构函数设为virtual,这样在析构时会先调用子类的析构函数,再调用基类的析构函数,否则如果delete的是基类的指针,则只调用基类的析构函数.示例如下:#include   class Base    {    public:    Base() { mPtr = new int; }   virtual ~Base() { delete

虚函数、普通成员函数访问类的数据成员：class A { protected:     int m_data; public:     A(int data = 0){ m_data = data;   }     int GetData(){ return doGetData();}     virtual   int   doGetData(){  return

int (*(*F(int,int)))(int)是什么类型？首先，int(*M)(int)，其中M为函数指针，则(*F)(int,int)=M，用N代替*F，F为指向N的指针，则N(int,int)=M，这表示N是一个函数，参数为2个int,其返回值为函数指针M。故F为函数指针，该函数指针所指向的函数的参数为2个int,返回值为函数指针。另：int a;int F();可以想

class CFurniture{public: CFurniture(): m_iWeith( 3){ cout  void SetWidth( int iWeight)  {  m_iWeith= iWeight; } void GetWidth(  )  {  cout  }protected: int m_iWeith;};class CBed : virtual public CFurniture // {public: void SetWidth( int iWeight)  {  m_iWei

#ifndef 头文件卫士是为了保证类的头文件在一个.cpp文件中被多次引用后会不会出现重复定义的问题,注意,只是防止在一个.cpp文件中被多次引用.#ifndef ELEMTYPE_H#define ELEMTYPE_H的意思是，如果前面没有定义ELEMTYPE_H，那么现在定义ELEMTYPE_H它不需要有值，只是表明是否被定义过，它是为了防止头文件的重复定义我举个简单的例子帮助你理解：你在a.h里定义了一个类a:class a{}然后在b.h里定义了一个类b，而且引用了a.h:#include "a.

<br />1.两个文件:a.h, main.cpp. main.cpp中#include "a.h":<br />此方法最好不用,因为最好不要在头文件里定义变量:<br />(1)[a.h]:<br />int b;//只有一行,定义int变量<br />(2) [main.cpp]:<br />#include "a.h" //可以,但如果有其他.cpp文件引用a.h则重定义(多个.cpp中)出错. <br />main(){ ...}<br />----------------------------

用friend可以让一个函数访问一个类的对象的私有成员,如果想让一个函数访问2个类的对象的私有成员,则必须在第2个类中声明第一个类为友元类,并且也声明该函数为友元函数"(1)CA.h:class CB;//前向声明使用CB类class CA{public: friend void FUNC( CA* pa, CB* pb);//友元函数}---------------------(2)CB.h:class CB{public: friend class CA;//声明CA为CB的友元类 friend voi

在win32的窗口程序中加入控制台console窗口:(1)头文件:#include #include #include using namespace std;(2)redirectIOToConsole()函数://使用控制台的输出void redirectIOToConso

题目网址:http://acm.hdu.edu.cn/showproblem.php?pid=1024HDACM1024 max sum plus plus:m个不相交子段的最大和:思路：dp[i][j]表示前j个元素分成i段的最优解，同时这个最优解是由a[j]元素结束的。转移方

内存对齐。对下面的类：       class       B{              public:int m_a;                     short int m_b;                     double m_c        private:                     int m_d;

#include using namespace std; class CDemo{ public: CDemo():str(NULL){} ~CDemo(){if(str) delete [] str;} char *str; }; int main() { CDemo d1; d1.str = new char[32]; strcpy(d1.s

#pragma pack(n) 字节对齐用法详解对 齐的作用和原因：各个硬件平台对存储空间的处理上有很大的不同。一些平台对某些特定类型的数据只能从某些特定地址开始存取。其他平台可能没有这种情况，但 是最常见的是如果不按照适合其平台要求对数据存放进行对齐，会在存取效率上带来损失。比如有些平台每次读都是从偶地址开始，如果一个int型（假设为32 位系统）如果存放在偶地址开始的地方，那么一个读周期就