抽象  封裝   繼承   多態(tài)

3：

類 對象 和成員

4：

#include <iostream>
using namespace std;
class Human //定義一個類
{ 
public: //公有成員
 void GetStature(); // 這里是調(diào)用 下面私有的身高
 void GetWeight(); //調(diào)用體重
private: //表示要被各個對象所封裝的 是私有的 不能被共享 要調(diào)用此成員 必須要在公有上調(diào)用
 int stature; //身高
 int weight;//體重  可以自定義
};// 這里要加 分號 代表該類結(jié)束

5：

#include <iostream>
using namespace std;
class Human // 關(guān)于習(xí)慣問題，一般 的 類 的命名 首字母為大寫 有的也有全部大寫或者全部小寫
{ 
public:
 void GetStature();   //這里由于是兩個單詞 所以 單詞首字母大寫 也有 get_stature
 void GetWeight();
private:
 int stature;  // 成員變量 這里一般 都為小寫
 int weight;
};
// 習(xí)慣問題都是 看個人或者公司安排 這樣可讀性強

 

6:

#include <iostream>
using namespace std;
class Human
{ 
public:
 void GetStature(){cout<<stature;}   //由于上一節(jié)只是申明一個成員函數(shù) 但是并沒有實現(xiàn)功能 所以在這里要讓他實現(xiàn) 輸出功能
 void GetWeight();
 void SetWeight(int j){weight=j;} //同下
 void Setstature(int i){stature=i;} //接受一個用戶輸入的值 int i 然后把 i 這個值 賦予給私有變量 stature
private:
 int stature; 
 int weight;
}; 
int main()
{
 int a,b;
    cout<<"請輸入一個值：\n";
 cin>>a;
    cout<<"請輸入一個值：\n";
 cin>>b;
 Human Mike;//這個是定義類中的對象。 Mike 就是對象 // 類是個虛擬的 而對象是個實實在在的
    Mike.Setstature(a); // 這里是輸入一個值   接這條語句 void Setstature(int i){stature=i;}
 Mike.GetStature();// 調(diào)用函數(shù)里面的功能， 就是輸出這個值
 Mike.SetWeight(b);
 Mike.GetWeight();
 return 0;
}
//對象是通過 . 來調(diào)用它的成員的 而對象是不能調(diào)用私有的成員數(shù)據(jù)的 必須要通過 公有的成員函數(shù) 來調(diào)用私有的成員數(shù)據(jù)
//下面是第二種方法定義 getweight 函數(shù)
void Human::GetWeight() //首先定義函數(shù)的返回值  當(dāng)通過類來訪問他的成員函數(shù)的時候 要通過:: 這個來訪問
{
 cout<<weight; //該函數(shù)的實現(xiàn)代碼 就是輸出 成員變量 體重
}
//很難把，建議多看下注釋。 雖然是俺打的注釋 不過俺也覺得有點難 其實多看幾遍就清楚 也很簡單
//如果你還是覺得不懂 建議看下我以前寫的 函數(shù)定義 方面的章節(jié)

 

7:

#include <iostream>
using namespace std;
class Human
{ 
public:
 void run(){cout<<"我是鬼，我會跑步\n";} //成員函數(shù)只能被對象調(diào)用
 void eat(){cout<<"我是鬼，我會吃人\n";}
 void speak(){cout<<"我是鬼，我會說話\n";}
 void walk(){cout<<"我是鬼，我會走路\n";}
}; 
int main()
{
   // 所謂的 類 是個抽象的概念 比如 int 你不可能給他直接賦值 為 int =1  只有 int a=1 才可以。
 //class 其實也是一個類型  所以 你不冷 human.weight  這樣 是錯誤的
 Human Tom; // 這里才是定義一個類的對象 只有對象才是存在的 才能被調(diào)用 就像下面這樣
 Tom.eat();
 Tom.run();
 Tom.speak();
 Tom.walk();
 return 0;
 // 如果你調(diào)用一個不存在的成員函數(shù) 那么將會 出錯 比如 Tom.wori(); “wori”: 不是“Human”的成員
}

8:

#include <iostream>
using namespace std;
class Human
{ 
public:
 int weight; //公有成員 可以被human 這個類所申明的對象 調(diào)用。如下面
 void set(int w) // 這里是設(shè)置 一個SET函數(shù) 并且接受用戶輸入的值 保存到W 把W賦值給 HIGHT 為什么要定義私有的成員？
  //因為可以提高安全性。比如下面 限定 用戶輸入的值 而且改動后 不會對下面的程序影響，便捷
 {
  if(w>0&&w<100)
   hight=w;
  else
  {
   cout<<"請輸入一個大于0而小于100的數(shù)，否則set 將返回0\n";
   hight=0;
         }
 }
 int print(){return hight;} //這里是設(shè)置一個 print 函數(shù)  前面有個INT 為返回值 所以要返回 hight 的值 因為上面
 // 是把w 賦值給 hight 所以才返回他
private:
 int hight; //如果是這種私有的成員變量，那么就應(yīng)該在公有上面設(shè)置函數(shù)才能調(diào)用
}; 
int main()
{
 Human tom; // 定義一個 tom 的對象
 tom.weight=4;
 cout<<"tom的體重為： "<<tom.weight<<endl;
 Human jack;//定義一個jack的對象 都可以調(diào)用
 jack.weight=5;
 cout<<"jack的體重為： "<<jack.weight<<endl;
 int b;
 cout<<"請輸入一個數(shù)：\n";
 cin>>b;
 Human guinaoer;
 guinaoer.set(b); // 上面已經(jīng)看到 是定義了一個 set 函數(shù) 用做接受 用戶輸入的值，所以我們要給他輸入個值
 cout<<"guinaoer的身高為： "<<guinaoer.print()<<endl; // set只用作 輸入 要輸出 所以是 print 函數(shù)
 return 0;
 // 如果你調(diào)用一個不存在的成員函數(shù) 那么將會 出錯 比如 Tom.wori(); “wori”: 不是“Human”的成員
}
//代碼有點多 不過都是我們學(xué)習(xí)過的 看起來應(yīng)該不難

 

9:

#include <iostream>
using namespace std;
class Human
{ 
public:
 void set(int)  //當(dāng)然你也可以只申明 在下面定義
 int print(){return hight;}
private:
 int hight;
}; 
int main()
{

}
void Human::set(int w); //這里開始定義
{
 if(w>0&&w<100)
  hight=w;
 else
 {
  cout<<"請輸入一個大于0而小于100的數(shù)，否則set 將返回0\n";
  hight=0;
 }
}

 

10:

#include <iostream>
using namespace std;
class Human
{
public:
 inline void set(int x,int y) //其實也只是在前面加了個 inline 注意申明在后面加; 非申明 不加。
 {
  i=x;
  j=y;
 }
 inline void print()
 {
  cout<<"兩個數(shù)相乘的結(jié)果為：\n"<<i*j<<endl;
 }
 //在函數(shù)體短小的情況下可以像上面用inline 調(diào)用 。內(nèi)斂函數(shù)
private:
 int i,j;
};
int main()
{
   Human Tom;
   Tom.set(2,3);
   Tom.print();
   return 0;
}
// 為什么要分開寫？因為如果全部寫在一起 會導(dǎo)致程序變大 因為他是一個程序集。所以
//分開寫 可以減少程序占用內(nèi)存。 比如調(diào)用100此 那他的體積就太大了。 而 inline　就是為了解決這個問題而誕生的
//但是 inline 也有問題 他也會復(fù)制100此這個函數(shù) 但是他不是復(fù)制的程序集 所以相對小店

 

11：

當(dāng)然 其實上面的代碼也可以分開寫。 把類的代碼

#include <iostream> 到  };   全部新建一個頭文件 保存到頭文件里面 比如 1.h

那么你只需要調(diào)用的時候這樣就可以了在CPP里面

#include "1.h"  這樣寫 的好處在于，大家可以分工合作 因為類不需要關(guān)心 調(diào)用這個類的細(xì)節(jié) 只需要自己編就可以了

 

12：

#include "iostream"
using namespace std;
class Human
{
public:
 void func(int x,int y) //const 這里如果加三const 的值。就會報錯 因為他試圖對私有成員 i 和 j進(jìn)行修改 所以報錯
 {
  i=x;
  j=y;
 }
 void print()const //加上const 的意思是，因為i 和j 值是被 print 輸出 而不是修改 ，所以 不會報錯
 {
  cout<<"兩個數(shù)相乘的結(jié)果為：\n"<<i*j<<endl;
 }
private:
  int i,j;
};//這樣做的好處是幫助你差錯 而且你如果確定參數(shù)不允許被修改 那么就 加上const
//在編程的時候 如果不修改的成員函數(shù) 那么就要加上const  這樣是編程的好習(xí)慣

 

13:

#include <iostream>
using namespace std;
class rectangle //構(gòu)造函數(shù)：由于在創(chuàng)建一個對象時 他的數(shù)據(jù) 不明確，所以要對其初始化。
 //假如我們在創(chuàng)建一個長方形的時候 要知道他的長和寬 但是不明確 就要使用構(gòu)造函數(shù) 就像這個例子一樣
{
public:
 rectangle(int a,int b) //區(qū)別在于 這里就是定義一個構(gòu)造函數(shù) 他是 rectangle 的構(gòu)造函數(shù) 用來構(gòu)造長方形
 {
  weight=a;
  lenght=b;
 }
 int areo()
 {
     return lenght*weight;
 }
private:
 int weight,lenght;
};
int main()
{
 rectangle a(3,4);
  cout<<a.areo();
 return 0;
}

 

14:

#include <iostream>
using namespace std;
class rectangle
{
public:
 rectangle(){cout<<"我是構(gòu)造函數(shù)：\n";} //這里是默認(rèn)的構(gòu)造函數(shù)。
 rectangle(int a,int b)
 {
  weight=a;
  lenght=b;
 }
 int areo()
 {
     return lenght*weight;
 }
private:
 int weight,lenght;
};
int main()
{
 rectangle a(3,4);
 rectangle b;//因為b 沒有被初始化 所以會調(diào)用默認(rèn)構(gòu)造函數(shù) 因為默認(rèn)構(gòu)造函數(shù)已經(jīng)被我們設(shè)定的默認(rèn)構(gòu)造函數(shù) 。像上面 我們就自己設(shè)置了一個默認(rèn)
 //構(gòu)造函數(shù) 所以輸出 了 上面的內(nèi)容
  cout<<a.areo();
 return 0;
}

 

15:

#include <iostream>
using namespace std;
class xyry
{
public:
    xyry();
 ~xyry(); //這里就是析構(gòu)函數(shù)的定義
};
xyry::xyry()
{
 cout<<"構(gòu)造函數(shù)執(zhí)行完畢\n";
}
xyry::~xyry()
{
 cout<<"析構(gòu)函數(shù)執(zhí)行完畢\n";
}
int main()
{
 xyry a; //這里開始是調(diào)用 默認(rèn)的構(gòu)造函數(shù)的功能 。
 return 0;
}//這里 由于 構(gòu)造函數(shù)已經(jīng)執(zhí)行完畢，所以到這里才執(zhí)行析構(gòu)函數(shù)。因為析構(gòu)函數(shù)是 釋放構(gòu)造函數(shù)的內(nèi)存空間 所以要在
//構(gòu)造函數(shù)執(zhí)行完畢后才執(zhí)行
//構(gòu)造函數(shù)和析構(gòu)函數(shù)都不能定義返回值 而且 析構(gòu)函數(shù)是不能加參數(shù)的 一個類中只能有一個析構(gòu)函數(shù)

 

16:

#include <iostream>
using namespace std;
class xyry
{
public:
    xyry();
 ~xyry();
};
xyry::xyry()
{
 cout<<"構(gòu)造函數(shù)執(zhí)行完畢\n";
}
xyry::~xyry()
{
 cout<<"析構(gòu)函數(shù)執(zhí)行完畢\n";
}
int main()
{
 xyry a[3];//定義數(shù)組 分別為 0 1 2 他會執(zhí)行三次 構(gòu)造函數(shù)和析構(gòu)函數(shù) 先執(zhí)行 3此構(gòu)造 在釋放構(gòu)造內(nèi)存三次
 return 0;
}

17:

#include <iostream>
using namespace std;
int main()
{
 int i=1;
number:i++; //這里的number 是一個標(biāo)號 是為了配合goto 語句的使用
 cout<<"*";
 if (i<10)
 {
  goto number; // goto 意思是跳轉(zhuǎn)到。。是個很古老的語句 ，goto 跳轉(zhuǎn)到標(biāo)號處在執(zhí)行 i++
 }
 cout<<"\n程序結(jié)束\n";
 cout<<"*********\n";
 return 0;
}
//goto語句要慎用 而且現(xiàn)在用的很少，因為 goto 語句可以跳轉(zhuǎn)到 程序任意位置 所以調(diào)試起來很難

 

18:

#include <iostream>
using namespace std;
int main()
{
 int i;
    cout<<"請輸入一個數(shù)：";
 std::cin>>i;
 while (i<100&&i>3)//這里是判斷輸入的數(shù)是不是小于100 而且大于3的數(shù)，如果為真  執(zhí)行大括號里面的 為假 就結(jié)束
 {
  cout<<"i:"<<i<<endl;
  i++;
 }
 return 0;
}//這個是 while 的語句使用方法，while 和if差不多 不過 if 是執(zhí)行一次 而 while 是執(zhí)行多次 直到 判斷為假的時候才結(jié)束

 

19:

#include <iostream>
using namespace std;
int main()
{
 char content='y';//這里定義為 y 是因為不這樣定義 程序就直接完了
 while (content=='y'||content=='Y')// 如果你輸入的字符不是 y 或者 Y 其中的一個 那么就退出
 {
  cout<<"\n這里是演示的語句，如果想在看到這條語句請按y 否則按n\n";
  cin>>content;
 }
 //下面的代碼是實現(xiàn)自定義循環(huán)次數(shù)的。
 int count,many;
 cout<<"\n請問你要看幾次？\n";
    cin>>count;
 many=0;
 while (many<count)
 {
  cout<<"HI,C++\n";
  many++;//這里必須加 因為 many的值為0  所以每次加1  這樣加到和用戶輸入的值一樣就退出循環(huán)
 }
 cout<<"\n程序執(zhí)行完畢\n";
    return 0;
}

 

20:

#include <iostream>
using namespace std;
int main()
{
 int a;
 a=0;
 while (a<6)
 {
  a++;
  if (a==1)
  {
   continue;//continue 的作用是 不執(zhí)行下面的語句 而跳轉(zhuǎn)到 while 繼續(xù)執(zhí)行。
   //這里 如果 a=1 的時候 那么就不會輸出a了 因為 continue 已經(jīng)忽略過了下面的語句
  }
  else if (a==4)
  {
   break; //break 的意思結(jié)束循環(huán)。 比如 如果 a 等于4 的時候 這條循環(huán)語句就會被強行終止然后跳到循環(huán)外面的語句繼續(xù)執(zhí)行
  }
  cout<<"a的值為："<<a<<endl;
 }
 cout<<"a的值為："<<a<<endl; //這里會輸出4 因為 a++的時候 a的值已經(jīng)是4了 所以才輸出4
 return 0;
}

 

21:

#include <iostream>
using namespace std;
int main()
{
 int a;//這里的a 必須要是外面 因為如果在 while里面 就變成無限循環(huán)了 a的值永遠(yuǎn)都是0
 a=0;
 while (1)// 1 的意思為真， 也可以寫為 真 這里的意思是 永遠(yuǎn)為真 如果沒有break 這里就是死循環(huán)
 {
  a++;
  int b;
  cout<<"請輸入一個數(shù)：";
  cin>>b;
  if (a>3)
  {
   break;
  }
 }
 cout<<"程序執(zhí)行了："<<a<<endl;
 cout<<"程序執(zhí)行完畢\n";
 return 0;
}

22:

#include <iostream>
using namespace std;
int main()
{
 int a,b;
 a=0;
 cout<<"你想看幾次？\n";
 cin>>b;
 do //do while 語句 的意思是 無論條件是否成立 都執(zhí)行 一次 。比如 如果你輸入0 在正常情況下會直接退出 不執(zhí)行 while 循環(huán)
 // 如果do while 那么將至少執(zhí)行一次
 {
  cout<<"狼牙月，伊人憔悴\n";
  a++;
 } while (a<b);// 后面要加 ;  這才代表這是一條語句
 return 0;
}

 

23:

#include <iostream>
using namespace std;
int main()
{
 int a,b;
 cout<<"你想看幾次？\n";
 cin>>b;
 for (a=0;a<b;a++) // for 循環(huán)語句的使用和 while 差不多 就是把 a=0 和 a++放入了 for判斷 語句中 。
  //需要注意的是第一個和第三個可以是語句 但是第二個 必須是表達(dá)式 for 比 while更加簡潔
 {
  cout<<"天涯何處無芳草\n";
 }
 return 0;
}

 

24:

#include <iostream>
using namespace std;
int main()
{
 for (int a=0,b=0,c=0;c<3;a++,b++,c++)//這里是比較靈活的運用for 循環(huán) 因為 for 支持三種參數(shù) 所以 可以用 ： 這個表示語句結(jié)束
  //如果是, 還可以繼續(xù)寫
 {
  cout<<"a:"<<a<<" b:"<<b<<" c:"<<c<<endl;
 }
 return 0;
}

 

25：

#include <iostream>
using namespace std;
int main()
{
 int a=0;
 for (;;)//條件為空的 for 循環(huán) 就是這樣的。 其實和 while(1) 是一樣的  可以換了試試看
 {
  if (a<5)
  {
   a++;
   cout<<"哦哦哦哦哦哦哦哦哦\n";
  }
  else
   break;
 }
 for (int b=0;b<3;cout<<"b: "<<b++<<endl)// 這里就是功能為空的語句 也可以這樣寫 雖然沒問題
  //但是卻不如把 cout 寫到 {} 里面
 {
  ;
 }
 return 0;
}

 

26:

#include <iostream>
using namespace std;
int main()
{
 int a,b;
 char c;
 cout<<"請輸入多少行：";
 cin>>a;
 cout<<"請輸入多少列：";
 cin>>b;
 cout<<"請輸入一個字：";
 cin>>c;
 for (int i=0;i<a;i++)//for循環(huán)嵌套。在這條語句中 這個是外層循環(huán)
 {
  for (int j=0;j<b;j++)//這個是內(nèi)循環(huán) 。
  {
   cout<<c;// 意思是 當(dāng)你輸入 2 3 a 的時候  外層進(jìn)行循環(huán) 當(dāng)?shù)竭@里的時候 開始了內(nèi)循環(huán) 只有 j<3的時候 才結(jié)束
   // 結(jié)束后 輸出 換行 因為b=3 所以這里要輸出 三個a  才會結(jié)束這條語句 接著換行 因為 a=2 所以還要執(zhí)行一次這個語句
  }
  cout<<"\n";
 }
 return 0;
}

 

27:

#include <iostream>
using namespace std;
int main()
{
 int a;
 cout<<"請輸入一個值：";
 cin>>a;
 switch (a) //把 a 作為判斷的條件。
 {
 case 0:cout<<"你輸入的數(shù)字是0";//判斷用戶輸入的數(shù)字是不是0 如果是 就輸出一段話
  break;//如果上面的判斷成立  那么就跳出 switch 語句
 case 1:cout<<"你輸入的數(shù)字是1";//判斷用戶輸入的數(shù)字是不是1 如果是 就輸出一段話
  break;
 case 2:cout<<"你輸入的數(shù)字是2";//同上 下面也是一樣的意思
  break;
 case 3:cout<<"你輸入的數(shù)字是3";
  break;
 case 4:cout<<"你輸入的數(shù)字是4";
  break;
 case 5:cout<<"你輸入的數(shù)字是5";
  break;
 case 6:cout<<"你輸入的數(shù)字是6";
  break;
 case 7:cout<<"你輸入的數(shù)字是7";
  break;
 default:cout<<"你輸入的數(shù)不是1-7的有效數(shù)字\n";//如果輸入的語句都不是 0-7  那么就默認(rèn)執(zhí)行這條語句
 }
 cout<<"程序執(zhí)行完畢\n";
 return 0;
}//switch 語句比IF 語句好用的地方就是 可以進(jìn)行多次判斷 如果判斷語句過多 if 使用起來是很麻煩的。 所以用 switch 語句

 

28:

#include <iostream>
using namespace std;
int main()
{
 int a;
 cout<<"請輸入一個值：";
 cin>>a;
 switch (a)
 {
 case 0:cout<<"你輸入的數(shù)字是0";
  //break;常見錯誤 沒有break 語句 將會出現(xiàn)的錯誤 如果輸入的是 0 因為 case 0 為真 所以從這里執(zhí)行
  //但是程序沒有break 所以不會跳出循環(huán)  還會一直執(zhí)行下面的 語句 全部輸出結(jié)束 如果 輸出的是1
  //那么就從 case 1開始執(zhí)行到完畢  同理也是一樣 你輸入的數(shù)字和case 為真 那就沖那里開始執(zhí)行
  //如果超出1-2 比如 3 那么程序?qū)⒅苯虞敵?你輸入的數(shù)不是1-7的有效數(shù)字
 case 1:cout<<"你輸入的數(shù)字是1";
  //break;
 case 2:cout<<"你輸入的數(shù)字是2";
  //break;
 default:cout<<"你輸入的數(shù)不是1-7的有效數(shù)字\n";
 }
 cout<<"程序執(zhí)行完畢\n";
 return 0;
}

 

29: