C++ 繼承測試

#include 
#include 
#pragma hdrstop

using namespace std;
//---------------------------------------------------------------------------

class A
{
private:
//   virtual void __fastcall virtual_private_pure()=0;
//   void __fastcall private_pure()=0;
   virtual void __fastcall virtual_private_A(){cout << "virtual_private_A" << endl;};
   void __fastcall private_A(){cout <<  "private_A" << endl;};
protected:
   virtual void __fastcall virtual_protected_pure()=0;
//   void __fastcall protected_pure()=0;
   virtual void __fastcall virtual_protected_A(){cout <<  "virtual_protected_A" << endl;};
   void __fastcall protected_A(){cout << "protected_A" << endl;};
public:
   virtual void __fastcall virtual_public_pure()=0;
//   void __fastcall public_pure()=0;
   virtual void __fastcall virtual_public_A(){cout << "virtual_public_A" << endl;};
   void __fastcall public_A(){cout <<  "public_A" << endl;};


   void A_get_private_A(){   private_A(); }
   void A_get_virtual_private_A(){   virtual_private_A(); }
   virtual void get_private_A(){   private_A(); }
   virtual void get_virtual_private_A(){   virtual_private_A(); }
   void get_private_A2(){   private_A(); }
   void get_virtual_private_A2(){   virtual_private_A(); }
   virtual void get_private_A3(){   private_A(); }
   virtual void get_virtual_private_A3(){   virtual_private_A(); }
   void void get_private_A4(){   private_A(); }
   void void get_virtual_private_A4(){   virtual_private_A(); }
};

class B : public A
{
private:
//   virtual void __fastcall virtual_private_pure()=0;  //no supported
//   void __fastcall private_pure()=0;                  //no supported

   //以下2個要宣告,否則後面func呼叫會失敗,有宣告仍可以達到繼承
   virtual void __fastcall virtual_private_A(){cout << "virtual_private_B" << endl;};
   void __fastcall private_A(){cout <<  "private_B" << endl;};
protected:
   virtual void __fastcall virtual_protected_pure(){cout << "virtual_protected_pure B" << endl;};
//   void __fastcall protected_pure()=0;                //no supported
   virtual void __fastcall virtual_protected_A(){cout <<  "virtual_protected_B" << endl;};
   void __fastcall protected_A(){cout << "protected_A" << endl;};
public:
   virtual void __fastcall virtual_public_pure(){cout << "virtual_public_pure B" << endl;};
//   void __fastcall public_pure()=0;                   //no supported
   virtual void __fastcall virtual_public_A(){cout << "virtual_public_B" << endl;};
   void __fastcall public_A(){cout <<  "public_B" << endl;};

   void B_get_private_A(){   private_A(); }
   void B_get_virtual_private_A(){   virtual_private_A(); }
   virtual void get_private_A(){   private_A(); }
   virtual void get_virtual_private_A(){   virtual_private_A(); }
   void get_private_A2(){   private_A(); }
   void get_virtual_private_A2(){   virtual_private_A(); }
   void  get_private_A3(){   private_A(); }
   void  get_virtual_private_A3(){   virtual_private_A(); }
   virtual get_private_A4(){   private_A(); }
   virtual get_virtual_private_A4(){   virtual_private_A(); }

};



#pragma argsused
int main(int argc, char* argv[])
{
        B b;
        A *pA = dynamic_cast(&b);


//private calling                                 exported B-func ,  exported A-func , privated-func
        b.B_get_private_A();                // B      non-virt               x             non-virt
        b.B_get_virtual_private_A();        // B      non-virt               x             virt
        b.get_private_A();                  // B      virt                 virt            non-virt
        b.get_virtual_private_A();          // B      virt                 virt            virt
        b.get_private_A2();                 // B      non-virt             non-virt        non-virt
        b.get_virtual_private_A2();         // B      non-virt             non-virt        virt
        b.get_private_A3();                 // B      non-virt             virt            non-virt
        b.get_virtual_private_A3();         // B      non-virt             virt            virt
        b.get_private_A4();                 // B      virt                 non-virt        non-virt
        b.get_virtual_private_A4();         // B      virt                 non-virt        virt

        pA->A_get_private_A();              // A      x                    non-virt        non-virt
        pA->A_get_virtual_private_A();      // B      x                    non-virt        virt(h)
        pA->get_private_A();                // B      virt(x)              virt(h)         non-virt
        pA->get_virtual_private_A();        // B      virt(x)              virt(h)         virt
        pA->get_private_A2();               // A      non-virt(x)          non-virt        non-virt
        pA->get_virtual_private_A2();       // B      non-virt(x)          non-virt        virt(h)
        pA->get_private_A3();               // B      non-virt(x)          virt(h)         non-virt
        pA->get_virtual_private_A3();       // B      non-virt(x)          virt(h)         virt
        pA->get_private_A4();               // A      virt(x)              non-virt        non-virt
        pA->get_virtual_private_A4();       // B      virt(x)              non-virt        virt(h)
        return 0;
}
//---------------------------------------------------------------------------

花博的花

畫花(6/2),剛開始真的沒什麼把握,連背景都拿不準
所以只好先鉤出大致的線條
至於背景就先不強求了(一步步來)


完成第1朵花的大致花形
有些感覺了,花感覺有浮起來
特別注意花瓣的走法,所以線條特別小心一條條來
避免看起來像一片的感覺
本來是想用一個"紅"色來表示深淺與陰影
不過看了後面第2朵後,發現應該要改一下


這一朵佔有先天的花形美觀
在光影上也比較豐富
不過如果只是用"紅色"來表示明暗深淺會大打折扣
所以加了一點其他顏色,發現更豐富了
這裡,有用了桔色,桔紅色跟藍色來豐富線條跟光影
這朵看來就活潑很多(可能跟原圖的表現也有關)
花蕊的部分,也是很重要的表現地方,整體畫龍點睛的意味
特別注意他的陰影,跟點上去的分佈狀況(花蕊摻了一點深紫色)


不過畢竟還太淺了,表現不出他的真的特色
覺得應該還可以加強不同顏色來製造出他的豐富性
背景的部分,就先不在這裡著墨太多,日後慢慢加強


完成後2朵花畢竟還是會比較一下,就來個特寫

報稅-稅籍編號

桃園縣查詢稅籍編號:http://www.tytax.gov.tw/core/query/houseno.php?REGION=1&VILLID=110&LAST_REGION=1

在縣市政府網站上查到的稅籍編號通常只有11碼而已。報稅軟體所需的稅籍編號要12號，缺少的一碼是所謂的縣市代碼，譬如像台北市是A，台南市是D。
縣市代碼詳列如下:
A 台北市，
B 台中市，
C基隆市，
D 台南市，
E 高雄市，
F 台北縣，
G 宜蘭縣，
H 桃園縣，
I 嘉義市，
J 新竹縣，
K 苗栗縣，
L 台中縣，
M 南投縣，
N彰化縣，
O 新竹市，
P 雲林縣，
Q 嘉義縣，
R 台南縣，
S 高雄縣，
T 屏東縣，
U 花蓮縣，
V 台東縣，
W 金門縣，
X 澎湖縣，
Y 陽明山，
Z 連江縣。
所以假設你在台中市查到的編號是 01234567890 的話，就要輸入 B01234567890 .