您现在的位置是：网站首页 -> 代码相关文章内容

C++内部类与私有静态成员-itarticl.cc-IT技术类文章记录&分享

发布时间: 9年前【代码相关】 226人已围观【返回】

1. 内部类的概念

如果一个类定义在另一个类的内部，这个内部类就叫做内部类。注意此时这个内部类是一个独立的类，它不属于外部类，更不能通过外部类的对象去调用内部类。外部类对内部类没有任何优越的访问权限。

即说：内部类就是外部类的友元类。注意友元类的定义，内部类可以通过外部类的对象参数来访问外部类中的所有成员。但是外部类不是内部类的友元。

2. 内部类可以定义在外部类的public、protected、private都是可以的。

如果内部类定义在public，则可通过外部类名::内部类名来定义内部类的对象。

如果定义在private，则外部不可定义内部类的对象，这可实现“实现一个不能被继承的类”问题。

3. 注意内部类可以直接访问外部类中的static、枚举成员，不需要外部类的对象/类名。

class A
{
private:
   static int k;
   int h;
public:
   class B
   {
       void foo()
       {
           cout << k << endl; //OK
           //cout<<h<<endl;//ERROR
       }
   };
};

int A::k = 3;

这里cout<<h<<endl;是一个非常常见的错误。因为内部类是一个独立的类，不属于外部类，所以此时还没有外部类的对象，显然也不存在h。而k就不同了，不需要外部类的对象就已存在，所以这里k是OK的。

这和友元类的使用也是同样的道理。“想要使用另一个类的成员，必须要存在这个类的对象”。

class A
{
private:
   static int k;
   int h;
public:
   class B
   {
       void foo(A a)
       {
           cout << k << endl; //OK
           cout << a.h << endl; //OK
       }
   };
};

int A::k = 3;

这样就没问题了。

4. 在堆中创建内部类对象：

class A
{
public:
   class B {};
};

int _tmain(int argc, _TCHAR *argv[])
{
   A::B *b = new A::B();
   return 0;
}

5.内部类可以现在外部类中声明，然后在外部类外定义：

class A
{
private:
   static int i;
public:
   class B;
};

class A::B
{
public:
   void foo()
   {
       cout << i << endl;   //!!!这里也不需要加A::i.
   }
};

int A::i = 3;

这形式上就更像友元类了。注意这里和友元类，不要混淆了。

6. sizeof(外部类)=外部类，和内部类没有任何关系。

class A
{
public:
   class B
   {
       int o;
   }
};

int _tmain(int argc, _TCHAR *argv[])
{
   cout << sizeof(A) << endl; //1
   return 0;
}

总结一下：其实内部类和友元类很像很像。只是内部类比友元类多了一点权限：可以不加类名的访问外部类中的static、枚举成员。其他的都和友元类一样。

私有成员变量

私有成员变量的概念，在脑海中的现象是，以private关键字声明，是类的实现部分，不对外公开，不能在对象外部访问对象的私有成员变量．

然而，在实现拷贝构造函数和赋值符函数时，在函数里利用对象直接访问了私有成员变量，因而，产生了困惑．下面以具体实例进行说明：

疑惑：为什么第26行和第32行代码可以编译通过，而第39行和第40行代码会产生编译错误？

class CTest {
public:
   CTest(int i);
   CTest(const CTest& rhs);
   CTest& operator=(const CTest& rhs);
   void printCTest(const CTest& rhs);
private:
   int value;
};

CTest::CTest(int i):value(i)
{
   cout<<"Contructor of CTest"<<endl;
}

CTest::CTest(const CTest& rhs):value(rhs.value)
{
   cout<<"Copy contructor of CTest"<<endl;
}

CTest& CTest::operator=(const CTest& rhs)
{
   cout<<"Assign function of CTest"<<endl;
   if(this == &rhs)
       return *this;
   value = rhs.value;                //通过对象访问私有成员变量
   return *this;
}

void CTest::printCTest(const CTest& rhs)
{
   cout<<rhs.value<<endl;        //通过对象访问私有成员变量
}

int main()
{
   CTest t = 1;
   CTest tt = 2;
   //  cout<<t.value<<endl;        //通过对象访问私有成员变量，编译错误
   //  cout<<tt.value<<endl;        //通过对象访问私有成员变量，编译错误
   t.printCTest(tt);
}