C++ 赎罪之路

实践目标：   1.c++ 类的定义

　　　　　　2.数据变量的定义

　　　　　　3.成员函数的声明以及定义

实例： 平年闰年的判断：

（相关注意点都在程序的注释当中）

#include <iostream>
    using namespace std;
    
    /*
        类的数据变量，以及类的成员函数的申明
    */
    class TDate {
        public:
            void SetDate(int y, int m, int d);
            int isLeapYear();
            void Print();
        private:
            int year,day,month;
    };  //类定义完成后加分号

    /*
        定义类的成员函数，且必须在程序中实现
    */
    void TDate :: SetDate(int y, int m, int d) {
        year = y ;
        month = m ;
        day = d ;
    }

    int TDate :: isLeapYear() {
        return (year%4==0 && year%100 != 0) || (year%400 == 0);
    }
    void TDate :: Print() {
        cout<<year<<"."<<month<<"."<<day<<endl ;
    }
    
    int main(){
        TDate td1 ;
        td1.SetDate(2009,5,10);
        int flag = td1.isLeapYear();
        td1.Print();
        if(flag == 1)
            cout<<"是闰年"<<endl ;
         else 
            cout<<"是平年！"<<endl ;
        return 0;
    }

---

8月29日晚上

饭后看了几个知识点，总结下（倒序）：

点击http://www.runoob.com/cplusplus/cpp-class-access-modifiers.html看一下继承的权限问题，讲的比较清楚！

1. 派生类：单一继承、多继承、权限问题、消除二义性、作用域分辨、

/*
*    派生类：（java中类的继承）
*/
#include <iostream>
using namespace std;

//默认为private A
class A {
    private:
        int a;
    public:
        A(int a){cout<<"this is A.a = "<<a<<endl;}
        ~A(){cout<<"dele A"<<endl;}
};

class B {
    private:
        int y ;
    public:
        B(int y) {cout<<"this is B.y = "<<y<<endl;}
        ~B() {cout<<"dele B"<<endl;}
};

/*
*    C 类继承A and B
*    格式： class 派生类名 : 访问控制 基类名 {访问控制：成员声明列表}；
*    多继承：class 派生类名 : 访问控制 基类名， 访问控制 基类名, ...{...}；
*/
class C :public A,public B {
    private:
        int c ;
    public:
        //构造函数初始化列表 java：C(){super.A()}
        C(int c, int x, int y):A(x),B(y) {
            cout<<"this is C.c = "<<c<<endl;
        }
    
        //析构函数
        ~C() {cout<<"dele C"<<endl;}
};

int main() {
    C c1(1, 2, 3);
    return 0;
}

权限、二义性、作用域分辨相关示例代码：

/*
*    派生类：（java中类的继承）
*/
#include <iostream>
using namespace std;

//默认为private A
class A {
    private:
        int a;
    public:
        A(int a){cout<<"this is A.a = "<<a<<endl;}
        ~A(){cout<<"dele A"<<endl;}
        
        void getA() {
            cout<<"getA()"<<endl;
        }
};

class B {
    private:
        int y ;
    public:
        B(int y) {cout<<"this is B.y = "<<y<<endl;}
        ~B() {cout<<"dele B"<<endl;}
        
        void getB(){
            cout<<"getB()"<<endl;
        }
};

/*
*    C 类继承A and B
*    格式： class 派生类名 : 访问控制 基类名 {访问控制：成员声明列表}；
*    多继承：class 派生类名 : 访问控制 基类名， 访问控制 基类名, ...{...}；
*/
class C :public A,public B {
    private:
        int c ;
    public:
        //构造函数初始化列表 java：C(){super.A()}
        C(int c, int x, int y):A(x),B(y) {
            cout<<"this is C.c = "<<c<<endl;
        }
    
        //析构函数
        ~C() {cout<<"dele C"<<endl;}
    
        void getC() {
            cout<<"getC()"<<endl;
        }
        void getB() {
            B::getB(); //作用域分辨
        }
};

int main() {
    C c1(1, 2, 3);
    cout<<endl<<endl;
    c1.getA();
    cout<<"error:c1.getB()"<<endl;
    
    /*
    *    消除二义性，使程序能够找到名字相同的成员函数不同作用域的实现
    */
    c1.getB();
    c1.getC();
    c1.B::getB(); //当继承B为private时 该句为错误，其他都能正常运行
    return 0;
}
-----------------------------------------------------------------------------
运行结果：
this is A.a = 2
this is B.y = 3
this is C.c = 1


getA()
error:c1.getB()
getB()
getC()
getB()
dele C
dele B
dele A

2. 静态成员（比较好理解，和可以借助java的静态成员作为理解，毕竟java是儿子）

---

9月3号 早上

指针：是一个变量，其值为另一个变量的地址，即，内存位置的直接地址。就像其他变量或常量一样，您必须在使用指针存储其他变量地址之前，对其进行声明。

 

例子2：

在指针中值得注意的是：可以进行比较;（感觉像是在地址进行再比较，其实是地址上的值进行比较，和java上的有些区别）

其他的运算时按照地址上的值进行运算的，都是通过指针的自增或自减实现指针向前、向后移动找到位置上的值来实现运算。

#include <iostream>

using namespace std;
const int MAX = 3;

int main ()
{
   int  var[MAX] = {10, 100, 200};
   int  *ptr;

   // 指针中第一个元素的地址
   ptr = var;
   int i = 0;
   while ( ptr <= &var[MAX - 1] )
   {
      cout << "Address of var[" << i << "] = ";
      cout << ptr << endl;

      cout << "Value of var[" << i << "] = ";
      cout << *ptr << endl;

      // 指向上一个位置
      ptr++;
      i++;
   }
   return 0;
}


--------------------------------------------------------------------------执行结果：
Address of var[0] = 0xbfce42d0
Value of var[0] = 10
Address of var[1] = 0xbfce42d4
Value of var[1] = 100
Address of var[2] = 0xbfce42d8
Value of var[2] = 200

 多态：基类指向子类的方法，子类重写基类的方法。

#include <iostream> 
using namespace std;
 
class Shape {
   protected:
      int width, height;
   public:
      Shape( int a=0, int b=0)
      {
         width = a;
         height = b;
      }
     virtual int area()  //virtual修饰后能够动态的绑定到子类的方法
      {
         cout << "Parent class area :" <<endl;
         return 0;
      }
};
class Rectangle: public Shape{
   public:
      Rectangle( int a=0, int b=0):Shape(a, b) { }
      int area ()
      { 
         cout << "Rectangle class area :" <<endl;
         return (width * height); 
      }
};
class Triangle: public Shape{
   public:
      Triangle( int a=0, int b=0):Shape(a, b) { }
      int area ()
      { 
         cout << "Triangle class area :" <<endl;
         return (width * height / 2); 
      }
};
// 程序的主函数
int main( )
{
   Shape *shape;                  
   Rectangle rec(10,7);
   Triangle  tri(10,5);
 
   // 存储矩形的地址
   shape = &rec;                  // Shape shape = new Rectangle();
   // 调用矩形的求面积函数 area
   shape->area();               //shape.area();
 
   // 存储三角形的地址
   shape = &tri;
   // 调用三角形的求面积函数 area
   shape->area();
   
   return 0;
}    

c++的数据封装

所谓的数据封装就是一个类的属性私有化，然后通过公共的方法（接口）让其对象进行调用，达到对属性的操作的目的；

接口（抽象类）：

#include <iostream>
 
using namespace std;
 
// 基类
class Shape 
{
public:
   // 提供接口框架的纯虚函数
   virtual int getArea() = 0;
   void setWidth(int w)
   {
      width = w;
   }
   void setHeight(int h)
   {
      height = h;
   }
protected:
   int width;
   int height;
};
 
// 派生类
class Rectangle: public Shape
{
public:
   int getArea()
   { 
      return (width * height); 
   }
};
class Triangle: public Shape
{
public:
   int getArea()
   { 
      return (width * height)/2; 
   }
};
 
int main(void)
{
   Rectangle Rect;
   Triangle  Tri;
 
   Rect.setWidth(5);
   Rect.setHeight(7);
   // 输出对象的面积
   cout << "Total Rectangle area: " << Rect.getArea() << endl;
 
   Tri.setWidth(5);
   Tri.setHeight(7);
   // 输出对象的面积
   cout << "Total Triangle area: " << Tri.getArea() << endl; 
 
   return 0;
}
--------------------------------------------------------------------------
运行结果：
Total Rectangle area: 35
Total Triangle area: 17
注意：在c++中没有重写的概念，只能是重载；接口就是一个公共的方法，但是是一个纯虚函数