#ifndef SMARTPOINTER_H
#define SMARTPOINTER_H


template
        
         
class SmartPointer
{
public:
  SmartPointer(T* ptr);
  ~SmartPointer();
  SmartPointer(SmartPointer
         
          & sptr); T* operator->(); T& operator*(); SmartPointer
          
           & operator=(SmartPointer
           
            & sptr); T getValue(); protected: T* ref; unsigned* ref_count; }; template
            
              SmartPointer
             
              ::SmartPointer(T* ptr){ ref = ptr; ref_count = (unsigned*)malloc(sizeof(unsigned)); *ref_count = 1; } template
              
                SmartPointer
               
                ::~SmartPointer(){ --*ref_count; if (*ref_count == 0) { delete ref; free(ref_count); ref = NULL; ref_count = NULL; } } template
                
                  SmartPointer
                 
                  ::SmartPointer(SmartPointer
                  
                   & sptr) { ref = sptr.ref; ref_count = sptr.ref_count; ++(*ref_count); } template
                   
                     T* SmartPointer
                    
                     ::operator->() { return ref; } template
                     
                       T& SmartPointer
                      
                       ::operator*() { return *ref; } template
                       
                         SmartPointer
                        
                         & SmartPointer
                         
                          ::operator=(SmartPointer
                          
                           & sptr){ if (this != &sptr) { ref = sptr.ref; ref_count = sptr.ref_count; ++(*ref_count); } return *this; } template
                           
                             T getValue() { return *ref; } #endif 
                           
                          
                         
                        
                       
                      
                     
                    
                   
                  
                 
                
               
              
             
            
           
          
         
        

#ifndef PERSON_H
#define PERSON_H

#include 
        
         
#include 
         
           using namespace std; class person { public: person(string name); ~person(void); void tell(); private: string name; }; #endif 
         
        

#include "person.h"

person::person(string name):name(name){
}
void person::tell(){
  cout << "Hi! I am " << name << endl;
}
person::~person(){
  cout << "Bye!" << endl;
}

另外一篇文章关于内部链接和外部连接的解释：

http://www.cnblogs.com/magicsoar/p/3840682.html

内部链接与外部链接

那么什么内部链接和外部链接又是什么呢？

我们知道C++中声明和定义是可以分开的

例如在vs中，我们可以一个函数声明定义放在b.cpp中，在a.cpp只需再声明一下这个函数，就可以在a.cpp中使用这个函数了

a.cpp

void show();

int main()
{
    show();
return 0;
}

b.cpp

#include 
        
         
void show()
{
    std::cout << "Hello" << std::endl;
}
        

而通过之前的了解，我们知道每个编译单元间是相互独立不知道彼此的存在的

那么a.cpp又是如何知道show函数的定义的呢

其实在编译一个编译单元(.cpp)生成相应的obj文件过程中

编译器会将分析这个编译单元(.cpp)

将其所能提供给其他编译单元(.cpp)使用的函数，变量定义记录下来。

而将自己缺少的函数，变量的定义也记录下来。

所以可以认为a.obj和b.obj记录了以下的信息

然后在链接器连接的时候就会知道a.obj需要show函数定义，而b.obj中恰好提供了show函数的定义，通过链接，在最终的可执行文件中我们能看到show函数的运行

哪这些又和内部链接，外部链接有什么关系呢？

那些编译单元(.cpp)中能向其他编译单元(.cpp)展示，提供其定义，让其他编译单元(.cpp)使用的的函数，变量就是外部链接，例如全局变量

而那些编译单元(.cpp)中不能向其他编译单元(.cpp)展示，提供其定义的函数，变量就是内部链接，例如static函数，inline函数等

好了让我们看下编译单元，内部链接和外部链接比较正式的定义吧

编译单元：当一个c或cpp文件在编译时，预处理器首先递归包含头文件，形成一个含有所有 必要信息的单个源文件，这个源文件就是一个编译单元。

内部连接：如果一个名称对编译单元(.cpp)来说是局部的，在链接的时候其他的编译单元无法链接到它且不会与其它编译单元(.cpp)中的同样的名称相冲突。

外部连接：如果一个名称对编译单元(.cpp)来说不是局部的，而在链接的时候其他的编译单元可以访问它，也就是说它可以和别的编译单元交互。

----------------------------------------------------------------------------------------------------------------------------------------

3. 使用下面两种方式防止重复include：

#ifndef PERSON_H
#define PERSON_H
#endif

或者

#pragma once

4. 给出在定义类内部可用常量，文件作用域常量，全局常量的写法：

a. 类成员变量是无法在成员变量定义的时候初始化的(除非是const static)，因此在这个时候，成员变量初始化列表是const变量初始化的唯一机会了。。。写成

class MyClass {

private:

const int a1 = 3;

const char* s1 = "abc";

}

是大错而且特错的！！！！同时注意只能在构造函数的初始化列表里初始化