Liny_@NotePad

沉迷ACG中

【20090819】C++培训日记-一些基础知识

YOYO posted @ 2009年8月19日 21:25 in 【C/C++】 , 2523 阅读

今天的作业包括：函数实现在类中和类外的差别、const的使用、基类使用虚析构函数、C++风格的强制转换、初始化列表与直接赋值的区别、内存分配

函数实现在类内和类外的区别：

如果在类内实现则默认是内联，如果要在类外实现内联函数，则需要加上inline来修饰。

const的使用：yoyo.is-programmer.com/posts/10611

  • 与指针混合使用：const T*或T const *， 当const在*左边时，表示指针所指向的值是常量，不可改变，但指针可以移动。（见下列代码中的ReadValueOnly1和ReadValueOnly2）
  • 与指针混合使用：T* const或const (T*) ， 当const在*右边时，表示指针是常量，不可移动，但是所指向的内容可以改变。（见下列代码中的ReadAddressOnly）
  • 与指针混合使用：当const在*的左右都有时，表示该指针是一个常量，不可移动，同时所指向的内容也是常量，不可改变。（见下列代码中的ReadBothOnly）
  • const修饰普通变量：在参数列表时可表示该参数仅作输入，不会对其值进行改变，修饰返回值时可以表示这个返回值不会被改变。
  • const修饰成员函数：表示该成员函数不会修改对象的成员变量（但可以修改static成员变量）。（见下列代码中的CTest::ReadOnly()）
     
  1. #include <iostream>
  2.  
  3. void ReadValueOnly1(const int* p)
  4. {
  5.         std::cout << "const int *" << std::endl;
  6.  
  7.         std::cout << (*p) << std::endl;
  8.  
  9.         p++;
  10.         std::cout << (*p) << std::endl;
  11.  
  12.         //(*p) ++;      //    error C3892: “p”: 不能给常量赋值
  13.         std::cout << (*p) << std::endl;
  14.  
  15.         std::cout << "====================" << std::endl;
  16. }
  17.  
  18. void ReadValueOnly2(int const * p)
  19. {
  20.         std::cout << "int const *" << std::endl;
  21.  
  22.         std::cout << (*p) << std::endl;
  23.  
  24.         p++;
  25.         std::cout << (*p) << std::endl;
  26.  
  27.         //(*p) ++;      //    error C3892: “p”: 不能给常量赋值
  28.         std::cout << (*p) << std::endl;
  29.  
  30.         std::cout << "====================" << std::endl;
  31. }
  32.  
  33. void ReadAddressOnly1(int * const p)
  34. {
  35.         std::cout << "int * const" << std::endl;
  36.  
  37.         std::cout << (*p) << std::endl;
  38.  
  39.         //p++;    //        error C3892: “p”: 不能给常量赋值
  40.         std::cout << (*p) << std::endl;
  41.  
  42.         (*p) ++;
  43.         std::cout << (*p) << std::endl;
  44.  
  45.         std::cout << "====================" << std::endl;
  46. }
  47.  
  48. //void ReadAddressOnly2(const (int *) p)
  49. //{
  50. //      std::cout << (*p) << std::endl;
  51. //
  52. //      p++;
  53. //      std::cout << (*p) << std::endl;
  54. //
  55. //      (*p) ++;
  56. //      std::cout << (*p) << std::endl;
  57. //}
  58.  
  59. void ReadBothOnly(const int * const p)
  60. {
  61.         std::cout << "const int * const" << std::endl;
  62.  
  63.         std::cout << (*p) << std::endl;
  64.  
  65.         //p++;    //        error C3892: “p”: 不能给常量赋值
  66.         std::cout << (*p) << std::endl;
  67.  
  68.         //(*p) ++;      //    error C3892: “p”: 不能给常量赋值
  69.         std::cout << (*p) << std::endl;
  70.  
  71.         std::cout << "====================" << std::endl;
  72. }
  73.  
  74. class CTestConst
  75. {
  76. public:
  77.         CTestConst(int _member): member(_member) { };
  78.         ~CTestConst(void) { };
  79.  
  80.         void Fun(void)
  81.         {
  82.                 std::cout << "test" << std::endl;
  83.         };
  84.  
  85.         void ReadMemberOnly() const
  86.         {
  87.                 std::cout << "const Member Function" << std::endl;
  88.  
  89.                 std::cout << member << std::endl;
  90.  
  91.                 //member++;     //    error C2166: 左值指定 const 对象
  92.                 std::cout << member << std::endl;
  93.  
  94.                 std::cout << s_var << std::endl;
  95.  
  96.                 s_var++;
  97.                 std::cout << s_var << std::endl;
  98.  
  99.                 std::cout << "====================" << std::endl;
  100.         };
  101.  
  102. private:
  103.         int member;
  104.         static int s_var;
  105. };
  106. int CTestConst::s_var = 30;
  107.  
  108. void main(void)
  109. {
  110.         int* p = new int[10];
  111.         for(int i=0; i<10; i++)
  112.         {
  113.                 p[i] = i+1;
  114.         }
  115.  
  116.         ReadValueOnly1(p);
  117.         ReadValueOnly2(p);
  118.  
  119.         ReadAddressOnly1(p);
  120.         //ReadAddressOnly2(p);
  121.  
  122.         ReadBothOnly(p);
  123.  
  124.         CTestConst test(1989);
  125.         test.Fun();
  126.         test.ReadMemberOnly();
  127.  
  128.         const CTestConst constTest = test;
  129.         //constTest.Fun();      //     不能将“this”指针从“const CTestConst”转换为“CTestConst &”
  130.         constTest.ReadMemberOnly();
  131.  
  132.         system("pause");
  133. }
 

基类要使用虚析构函数：

        没有使用虚析构函数的类见CBase，它对应的子类是CDerived，可以看到在用CBase指针指向CDerived对象，要删除该指针所指向内容的时候，并不会调用子类的析构函数，而使用CDerived指针指向CDerived对象时顺序是正常的;
        而使用了虚析构函数的类CBaseVirtual，对应子类CDerivedVirtual，不论指向子类对象的是父类指针还是子类指针，删除该指针所指向内容的时候都会正常调用子类的析构函数和父类的析构函数。

  1. #include <iostream>
  2.  
  3. class CBase
  4. {
  5. public:
  6.         CBase()
  7.         {
  8.                 std::cout << "CBase()" << std::endl;
  9.         };
  10.         ~CBase()
  11.         {
  12.                 std::cout << "~CBase()" << std::endl;
  13.         };
  14. };
  15.  
  16. class CDerived: public CBase
  17. {
  18. public:
  19.         CDerived()
  20.         {
  21.                 std::cout << "CDerived()" << std::endl;
  22.         };
  23.         ~CDerived()
  24.         {
  25.                 std::cout << "~CDerived()" << std::endl;
  26.         };
  27. };
  28.  
  29. class CBaseVirtual
  30. {
  31. public:
  32.         CBaseVirtual()
  33.         {
  34.                 std::cout << "CBaseVirtual()" << std::endl;
  35.         };
  36.         virtual ~CBaseVirtual()
  37.         {
  38.                 std::cout << "~CBaseVirtual()" << std::endl;
  39.         };
  40. };
  41.  
  42. class CDerivedVirtual: public CBaseVirtual
  43. {
  44. public:
  45.         CDerivedVirtual()
  46.         {
  47.                 std::cout << "CDerivedVirtual()" << std::endl;
  48.         };
  49.         ~CDerivedVirtual()
  50.         {
  51.                 std::cout << "~CDerivedVirtual()" << std::endl;
  52.         };
  53. };
  54.  
  55. void main(void)
  56. {
  57.         CBase* pBase = new CDerived;
  58.         delete pBase;
  59.         std::cout << "################################" << std::endl;
  60.  
  61.         CDerived* pDerived = new CDerived;
  62.         delete pDerived;
  63.         std::cout << "################################" << std::endl;
  64.  
  65.         CBaseVirtual* pBaseVirtual = new CDerivedVirtual;
  66.         delete pBaseVirtual;
  67.         std::cout << "################################" << std::endl;
  68.  
  69.         CDerivedVirtual* pDerivedVirtual = new CDerivedVirtual;
  70.         delete pDerivedVirtual;
  71.         std::cout << "################################" << std::endl;
  72.  
  73.         getchar();
  74. }

C++风格的强制转换：

  • static_cast：在编译时转换
    用法：static_cast < type-id > ( expression )     
    该运算符把expression转换为type-id类型，但没有运行时类型检查来保证转换的安全性。它主要有如下几种用法：
    ①用于类层次结构中基类和子类之间指针或引用的转换。
    　　进行上行转换（把子类的指针或引用转换成基类表示）是安全的；
    　　进行下行转换（把基类指针或引用转换成子类表示）时，由于没有动态类型检查，所以是不安全的。
    ②用于基本数据类型之间的转换，如把int转换成char，把int转换成enum。这种转换的安全性也要开发人员来保证。
    ③把空指针转换成目标类型的空指针。
    ④把任何类型的表达式转换成void类型。
    注意：static_cast不能转换掉expression的const、volitale、或者__unaligned属性。
    1. #include <iostream>
    2.  
    3. class CBase
    4. {
    5. public:
    6.         CBase(void)
    7.         {
    8.         };
    9. };
    10.  
    11. class CDerived: public CBase
    12. {
    13. };
    14.  
    15. class CDerivedSecond: public CBase
    16. {
    17.  
    18. };
    19.  
    20. /*
    21.         注意：static_cast不能转换掉expression的const、volitale、或者__unaligned属性。
    22. */
    23. void main(void)
    24. {
    25.         /*
    26.                 用法一：用于类层次结构中基类和子类之间指针或引用的转换。
    27.         */
    28.         {
    29.                 CBase objBase;
    30.                 CDerived objDerived;
    31.  
    32.                 CBase objBaseByCast = static_cast<CBase>(objDerived);
    33.                 //      CDerived objDerivedByCast = static_cast<CDerived>(objBase);   //  error C2440: “static_cast”: 无法从“CBase”转换为“CDerived”
    34.  
    35.                 //      进行上行转换（把子类的指针或引用转换成基类表示）是安全的
    36.                 CBase& rBase = static_cast<CBase&>(objDerived);
    37.                 CBase* pBase = static_cast<CBase*>(&objDerived);
    38.  
    39.                 //      进行下行转换（把基类指针或引用转换成子类表示）时，由于没有动态类型检查，所以是不安全的
    40.                 CDerived& rDerived = static_cast<CDerived&>(objBase);
    41.                 CDerived* pDerived = static_cast<CDerived*>(&objBase);
    42.         }
    43.  
    44.         /*
    45.                 用法二：用于基本数据类型之间的转换。这种转换的安全性也要开发人员来保证。
    46.         */
    47.         {
    48.                 int i = 30;
    49.                 char ch = static_cast<char>(i);
    50.  
    51.                 std::cout << ch << std::endl;
    52.         }
    53.  
    54.         /*
    55.                 用法三：把空指针转换成目标类型的空指针。
    56.         */
    57.         {
    58.                 CBase* pBase = NULL;
    59.                 void* pVoid = static_cast<void*> (pBase);
    60.  
    61.                 int* pInt = static_cast<int*> (pVoid);
    62.         }
    63.  
    64.         /*
    65.                 用法四：把任何类型的表达式转换成void类型。
    66.         */
    67.         {
    68.                 static_cast<void>(3.14159f);
    69.         }
    70.  
    71.         /*
    72.                 错误用法：指向类型无关
    73.         */
    74.         {
    75.                 float* pFloat = new float(3.14f);
    76.                 //int* pInt = static_cast<int*> (pFloat);       //     无法从“float *”转换为“int *”
    77.         }
    78.  
    79.         /*
    80.                 错误用法：虽然没有报错，但是没有意义，创建垃圾指针
    81.         */
    82.         {
    83.                 int* pInt = new int(3);
    84.                 int* pRubbish = static_cast<int*> (pInt);
    85.         }
    86.  
    87.         /*
    88.                 错误用法：交叉转换
    89.         */
    90.         try
    91.         {
    92.                 //      CDerivedSecond objDerivedSecond;
    93.  
    94.                 //      CDerived objDerived = static_cast<CDerived> (objDerivedSecond);       //     error C2440: “static_cast”: 无法从“CDerivedSecond”转换为“CDerived”
    95.                 //      CDerived* pDerived = static_cast<CDerived*> (&objDerivedSecond);      //    error C2440: “static_cast”: 无法从“CDerivedSecond *__w64 ”转换为“CDerived *”
    96.                 //      CDerived& rDerived = static_cast<CDerived&> (objDerivedSecond);              //     error C2440: “static_cast”: 无法从“CDerivedSecond”转换为“CDerived &”
    97.  
    98.                 //      std::cout << pDerived << " " << &objDerivedSecond << std::endl;
    99.         }
    100.         catch(std::bad_cast)
    101.         {
    102.                 std::cout << "Catch Bad Cast CRASH at LINE " << __LINE__ << std::endl;
    103.         }
    104.  
    105.         system("pause");
    106. }
  • dynamic_cast：在运行时转换
    用法：dynamic_cast < type-id > ( expression )
    该运算符把expression转换成type-id类型的对象。Type-id必须是类的指针、类的引用或者void *；
    如果type-id是类指针类型，那么expression也必须是一个指针，如果type-id是一个引用，那么expression也必须是一个引用dynamic_cast主要用于类层次间的上行转换和下行转换，还可以用于类之间的交叉转换。
    在类层次间进行上行转换时，dynamic_cast和static_cast的效果是一样的；
    在进行下行转换时，dynamic_cast具有类型检查的功能，比static_cast更安全。
    1. #include <iostream>
    2.  
    3. /*
    4. * 基类必须有virtual函数，否则dynamic_cast时会编译出错：
    5. *      error C2683: “dynamic_cast”:“CBase”不是多态类型
    6. */
    7. class CBase
    8. {
    9. public:
    10.         virtual void foo() { };
    11. };
    12.  
    13. class CDerived: public CBase
    14. {
    15.  
    16. };
    17.  
    18. class CDerivedSecond: public CBase
    19. {
    20.  
    21. };
    22.  
    23. void main(void)
    24. {
    25.         CBase objBase;
    26.         CDerived objDerived;
    27.  
    28.         CBase* pBase;
    29.         CDerived* pDerived;
    30.  
    31.         try
    32.         {
    33.                 pBase = dynamic_cast<CBase*> (&objDerived);
    34.                 pDerived = dynamic_cast<CDerived*> (&objBase);
    35.  
    36.                 CBase& rBase = dynamic_cast<CBase&> (objDerived);
    37.                 CDerived& rDerived = dynamic_cast<CDerived&> (objBase);
    38.         }
    39.         catch (std::bad_cast)
    40.         {
    41.                 std::cout << "Catch Bad Cast CRASH at LINE " << __LINE__ << std::endl;
    42.         }
    43.  
    44.         std::cout << pBase << " " << &objDerived << std::endl;
    45.         std::cout << pDerived << " " << &objBase << std::endl;  //        空指针
    46.  
    47.         /*
    48.                 dynamic_cast 还支持交叉转换（cross cast）
    49.         */
    50.         CDerivedSecond objDerivedSecond;
    51.  
    52.         try
    53.         {
    54.                 pDerived = dynamic_cast<CDerived*> (&objDerivedSecond);
    55.                 CDerived& rDerived = dynamic_cast<CDerived&> (objDerivedSecond);
    56.         }
    57.         catch(std::bad_cast)
    58.         {
    59.                 std::cout << "Catch Bad Cast CRASH at LINE " << __LINE__ << std::endl;
    60.         }
    61.  
    62.         std::cout << pDerived << " " << &objDerivedSecond << std::endl; //       空指针
    63.  
    64.         system("pause");
    65. }
  • const_cast
    用法：const_cast<type_id> (expression)
    该运算符用来修改类型的const或volatile属性。除了const 或volatile修饰之外， type_id和expression的类型是一样的。
    常量指针被转化成非常量指针，并且仍然指向原来的对象；
    常量引用被转换成非常量引用，并且仍然指向原来的对象；常量对象被转换成非常量对象。
    1. #include <iostream>
    2.  
    3. /*
    4.         const_cast 可以：
    5.         将常量指针转换为非常量指针;
    6.         将常量引用转换为非常量引用;
    7.         将常量对象转换为非常量对象。
    8. */
    9. void main(void)
    10. {
    11.         const int* pInt1 = new int(5);
    12.         //      *pInt1 = 3;   //  error C3892: “pInt1”: 不能给常量赋值
    13.         std::cout << *pInt1 << std::endl;
    14.  
    15.         int* pInt2 = const_cast<int*>(pInt1);
    16.         std::cout << *pInt2 << std::endl;
    17.  
    18.         *pInt2 = 2;
    19.         std::cout << *pInt2 << std::endl;
    20.  
    21.         system("pause");
    22. }
  • reinterpret_cast
    用法：reinpreter_cast<type-id> (expression)
    type-id必须是一个指针、引用、算术类型、函数指针或者成员指针。
    它可以把一个指针转换成一个整数，也可以把一个整数转换成一个指针（先把一个指针转换成一个整数，
    在把该整数转换成原类型的指针，还可以得到原先的指针值）。
    1. #include <iostream>
    2.  
    3. class A
    4. {
    5.  
    6. };
    7.  
    8. class B
    9. {
    10.  
    11. };
    12.  
    13. /*
    14.         reinterpret_cast
    15.         该函数将一个类型的指针转换为另一个类型的指针。
    16.         这种转换不用修改指针变量值存放格式(不改变指针变量值)，只需在编译时重新解释指针的类型就可做到。
    17.         reinterpret_cast 可以将指针值转换为一个整型数，但不能用于非指针类型的转换。
    18. */
    19. void main(void)
    20. {
    21.         //      基本类型指针的类型转换
    22.         double d = 3.14;
    23.         int* pI = reinterpret_cast<int*> (&d);  //        相当于 (int*) (&d)
    24.         std::cout << (*pI) << std::endl;
    25.  
    26.         //      不相关的类的指针的类型转换
    27.         A* a = new A;
    28.         B* b = reinterpret_cast<B*> (a);
    29.         std::cout << &b << " " << &a << std::endl;
    30.  
    31.         //      指针转换为整数
    32.         long lAddress = reinterpret_cast<long> (&d);
    33.         std::cout << lAddress << std::endl;
    34.  
    35.         system("pause");
    36. }

总结：
static_cast用于内建数据类型之间的转型。
reinterpret_cast用于对变量重新进行二进制解释，因此它的转型结果是编译器实现相关(implementation-dependent)的，不是可移植的，一般在实践中，只有迫不得已，才使用这种转型。例如直接将整数常量转型为某个自定义的struct类型，驱动程序的编写中常常使用这种技术。
dynamic_cast用于在继承体系中进行安全的向下转型(downcast)，也就是从基类指针/引用向派生类指针/引用的转型。
const_cast用于取消变量的常量性修饰。

以及其他显示转换：

  • itf_cast：例子貌似都是用COM的IHTML什么来写的……看不懂 = = 先放着···
  • stream_cast
    1. #include <iostream>
    2. #include <sstream>
    3. #include <string>
    4.  
    5. /************************************************************************/
    6. /* 如果已经定义了输入和输出
    7. /* 准确地来说，
    8. /* 源类型定义了输出（<<），目标类型定义了输入（>>）
    9. /* 就可以使用stream_cast进行转换。
    10. /*
    11. /*      std::stringstream 属于 <sstream>
    12. /************************************************************************/
    13. template<typename T1, typename T2>
    14. T1 stream_cast(const T2& t2)
    15. {
    16.         std::stringstream str;
    17.         str << t2;
    18.  
    19.         T1 t1;
    20.         str >> t1;
    21.  
    22.         if(!str)
    23.         {
    24.                 throw std::bad_cast();
    25.         }
    26.  
    27.         return t1;
    28. }
    29.  
    30. void main(void)
    31. {
    32.         std::string s("0.5");
    33.         double d = stream_cast<double>(s);
    34.  
    35.         std::cout << d << std::endl;
    36.  
    37.         getchar();
    38. }
  • safe_cast
    1. #include <iostream>
    2.  
    3. /************************************************************************/
    4. /* 如果我们希望(T2)(T1)t2 == t2，即无损失的转换，可以使用safe_cast
    5. /************************************************************************/
    6. template<typename T1, typename T2>
    7. T1 safe_cast(const T2& t2)
    8. {
    9.         if((T2)(T1)t2 != t2)
    10.         {
    11.                 throw std::bad_cast();
    12.         }
    13.         return (T1)t2;
    14. }
    15.  
    16. void main(void)
    17. {
    18.         try
    19.         {
    20.                 int i = 5;
    21.                 double c = safe_cast<double> (i);
    22.        
    23.                 double d = 2.4;
    24.                 float f = safe_cast<float> (d);
    25.         }
    26.         catch (std::bad_cast)
    27.         {
    28.                 std::cout << "Bad Cast at " << __LINE__ << std::endl;
    29.         }
    30.  
    31.         getchar();     
    32. }

初始化列表与构造函数内部直接赋值：http://yoyo.is-programmer.com/posts/10610

其他待继续笔记……

  • 无匹配
Small_feed 评论 (0)

登录 *


loading captcha image...
(输入验证码)
or Ctrl+Enter