精华内容
下载资源
问答
  • 基类protected成员

    千次阅读 2014-07-27 18:23:27
    2014-07-27 星期日 18:10:56 ...1、基类protected成员 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

    2014-07-27 星期日 18:10:56

    重温下c++ primer,随意记录。

    1、基类protected成员
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    #include <iostream>
    #include <iterator>
    #include <vector>
    #include <algorithm>
    #include <utility>
    #include <string>
     
    using  namespace  std;
     
    /*
    如果没有继承,
    类只有两种用户:
    1:类本身的成员
    2:类的用户(instance或有效的ptr&ref)
     
    有继承
    3:derive:public/protected/private均可
     
    derive可以访问base protected,不可以访问base private
     
    希望禁止derive访问的成员应该设为 private
    希望提供derive实现所需方法或数据的成员应设为 protected。
     
    所以
    base提供给derive的接口应该是
    protected 成员和 public 成员的组合。
     
    */
    class  base
    {
    public :
         base():m_base(3){}
         virtual  ~base(){}
         
    protected :
         int  m_base;
    };
     
    class  derive: private  base
    {
    public :
         derive():m_derive(4){}
    public :
         void  access( const  base& refb,  const  derive& refd)
         {
             /*
             此外,protected 还有另一重要性质:
             派生类只能通过派生类对象访问其基类的 protected 成员,
             派生类对其基类类型对象的 protected 成员没有特殊访问权限。
             */
             //cout << "refb.m_base  : "<< refb.m_base<< endl;
     
             /*
             15.2.2. protected 成员
             可以认为 protected 访问标号是 private 和 public 的混合:
             .像 private 成员一样,protected 成员不能被类的用户访问。
             .像 public  成员一样,protected 成员可被该类的派生类访问。
             */     
             cout <<  "refd.m_base  : " << refd.m_base<< endl;
             cout <<  "refd.m_derive: " << refd.m_derive<< endl;
         }
    protected :
         int  m_derive;
    };
     
    int  main ( int  argc, char  *argv[])
    {
    #if 1
         base b;
         base *pb =  new  base();
         //cout << "m_base  : "<< b.m_base<< endl;
     
         derive d;
         d.access(b, d);
    #endif
         return  0;
    }



    展开全文
  • C# 里面,接口的定义只需要类里面存在和接口声明相同的方法或属性就可以,而存在的方法或属性是子类定义的还是基类里面定义的都无所谓。也就是在基类里面写好了方法,但不继承接口,等子类继承接口的时候就不...

    在 C# 里面,接口的定义只需要类里面存在和接口声明相同的方法或属性就可以,而存在的方法或属性是在子类定义的还是基类里面定义的都无所谓。也就是在基类里面写好了方法,但不继承接口,等子类继承接口的时候就不需要子类实现方法。通过这样的方法可以在基类里面添加一些辅助方法,而这些方法默认不给子类开启,除非子类继承了接口

    在基类定义的方法,如果在子类继承的接口里面声明的方法刚好和基类定义的相同,那么子类可以不需要再次定义。在基类可以判断当前自己的类型是否继承了接口

    这个方法用在基类里面期望在特定的代码里面给子类暴露一些内部的方法,但是又不能让子类随意调用。或者预设了一些方法,这些方法存在性能或其他的问题,只有子类声明自己需要这个功能的时候才被调用

    内部方法隐藏

    在基类里面有一些内部的方法,默认不让子类使用的,但只有某些特殊的子类的情况才能被使用。同时这些内部方法还可能被外部的其他方法调用,不一定是子类

    按照以上的约定就可以写出如下代码

        public interface ILindexiDb
        {
            string GetPrivateString();
        }
    
        public class BassClass
        {
            public string GetPrivateString()
            {
                if (!(this is ILindexiDb))
                {
                    throw new NotSupportedException("这个方法除非是林德熙逗比才能使用,其他人不能使用");
                }
    
                return "林德熙是逗比";
            }
        }
    

    从代码可以看到,除非这个类继承了 ILindexiDb 不然 GetPrivateString 方法将会异常,因为我期望这个方法只有我才能调用

    那么假如我有一个 Foo 的接口里面就需要使用到对应的方法,而默认业务想要返回的方法是基类定义的上面的方法

        public interface IFoo
        {
            void GetString();
        }
    
    

    不明真相的小伙伴可能会如何写?

        public class Foo : BassClass, IFoo
        {
            public void GetString()
            {
                Console.WriteLine(GetPrivateString());
            }
        }
    

    上面代码是小伙伴会直接写出的代码,然而这段代码没有运行的时候就会炸,原因是在基类判断当前这个类没有继承林德熙是逗比这个接口

    在我将基类放在一个程序集编译为dll之后,小伙伴没有方法直接看到源代码,他在调用 GetPrivateString 方法的时候抛出了方法没有支持异常,于是小伙伴会认为这个方法还没实现,她就不会想要去使用这个方法

    而林德熙逗比将会写出下面代码用来访问内部的方法

        public class Foo2 : BassClass, ILindexiDb, IFoo
        {
            public void GetString()
            {
                Console.WriteLine(GetPrivateString());
            }
        }
    

    因为注入的都是 IFoo 接口,小伙伴都不知道实际实现的 Foo2 里面做了什么,如果不信,请在 VisualStudio 里面用上代码,然后调试一下。此时很难知道 Foo2 里面做了什么魔法让调用 GetPrivateString 方法不会异常,因为在调试的时候是很难知道当前这个类继承了哪些接口,而一般调试的时候都不会注意到某个类继承的接口会影响到具体调用的方法

    我写了很多调试的方法,请看dotnet 代码调试方法

    引用子类方法

    按照这个约定,其实还可以让基类在满足一定条件的时候才能执行,这个条件需要子类定义。这个方法是上面说到的内部方法隐藏的升级,用起来将会更复杂

    在基类里面判断当前类是否继承了某个接口,如果继承了,那么将会可以调用接口的方法。这个方法一般用在某个接口的声明要用到很多基类的信息才能实现,或某个接口本身不适合在外部的其他类继承,只能由子类继承

    例如我定义了接口,用来判断林德熙是不是逗比的接口,而这个接口的方法实现需要依赖于基类的内容才能判断,但基类的内容是私有的,从业务上也不应该让外部方法知道

        public interface ILindexiConverter
        {
            bool CheckLindexiIsDoubi();
        }
    

    以下是基类的定义

        public class BassClass
        {
            protected string Name { get; } = "林德熙逗比";
    
            public string GetPrivateString()
            {
                // 忽略代码
            }
        }
    

    基类里面定义的 Name 属性是不能给外部类知道的,要不大家都知道我逗比,只有子类才能知道

    此时基类需要依赖 ILindexiConverter 的判断才能决定是否需要做业务

            public string GetPrivateString()
            {
                // 忽略代码
    
                    if (!lindexiConverter.CheckLindexiIsDoubi())
                    {
                        throw new NotSupportedException("这个方法除非是林德熙逗比才能使用,其他人不能使用");
                    }
    
            }
    

    然而 ILindexiConverter 接口除非是子类,其他类是无法按照预期做到的,于是在基类里面可以这样写

                if (this is ILindexiConverter lindexiConverter)
                {
                    if (!lindexiConverter.CheckLindexiIsDoubi())
                    {
                        throw new NotSupportedException("这个方法除非是林德熙逗比才能使用,其他人不能使用");
                    }
                }
    

    判断当前这个类是否有继承 ILindexiConverter 接口,如果有就调用方法,按照这个方式写小伙伴就更加不能简单调用这个方法

    而作为逗比我将会写出下面的代码,用于调用

        public class Foo2 : BassClass, ILindexiDb, IFoo, ILindexiConverter
        {
            public void GetString()
            {
                Console.WriteLine(GetPrivateString());
            }
    
            /// <inheritdoc />
            public bool CheckLindexiIsDoubi()
            {
                return base.Name == "林德熙逗比";
            }
        }
    

    我在 Foo2 里面的 CheckLindexiIsDoubi 用到基类的属性判断,同时基类因为子类继承了预期接口而能使用

    这就是通过在基类里面定义好方法和定义好代码逻辑,只要子类继承接口才能实现

    我搭建了自己的博客 https://blog.lindexi.com/ 欢迎大家访问,里面有很多新的博客。只有在我看到博客写成熟之后才会放在csdn或博客园,但是一旦发布了就不再更新

    如果在博客看到有任何不懂的,欢迎交流,我搭建了 dotnet 职业技术学院 欢迎大家加入

    知识共享许可协议
    本作品采用知识共享署名-非商业性使用-相同方式共享 4.0 国际许可协议进行许可。欢迎转载、使用、重新发布,但务必保留文章署名林德熙(包含链接:http://blog.csdn.net/lindexi_gd ),不得用于商业目的,基于本文修改后的作品务必以相同的许可发布。如有任何疑问,请与我联系

    展开全文
  • 基类protected能被子类直接调用

    千次阅读 2015-09-19 11:04:09
    公有继承不改变基类成员的属性,也就是说基类protected成员子类中还是protected属性。 而类的对象是不能访问protected成员的,但类的成员函数是能访问protected成员的。 所以,基类的成员函数能调用自己的...

    公有继承不改变基类成员的属性,也就是说基类的protected成员在子类中还是protected属性。

    而类的对象是不能访问protected成员的,但类的成员函数是能访问protected成员的。

    所以,基类的成员函数能调用自己的protected成员(其对象不能),子类的成员函数也能调用基类的protected成员(其对象不能)


    class A{
    public:
        A(int x,int y):x(x),y(y){}
    protected:
        void print()
        {cout<<"x point:"<<x<<endl<<"y point:"<<y<<endl;}
    private:
        int x;
        int y;
    };
    class B:public A{
    public:
        B(int x,int y,int z):A(x,y),z(z){}
        void output()
        {print();cout<<"z point:"<<z<<endl;}//此处调用了基类的protected成员print(),这是合法的。
    private:
        int z;
    };
    int main()
    {
        A a(2,3);
        B b(4,5,6);
        //a.print();//这是不合法的,基类对象不能调用保护属性成员
        //b.print();//不合法
        b.output(); //调用public成员,合法;该成员函数内部调用了保护成员print()
        return 0;
    }

    综上:保护成员在对于类对象来说访问权限和私有成员一样,但是对于子类来说,子类能访问基类保护成员,但不能访问基类私有成员。

    展开全文
  • 经查阅资料 个人理解是这样的:只有派生类中的作用域中(譬如派生类中的函数)才可以通过派生类对象访问基类protected成员,派生类中也不可以直接访问基类对象的protected成员。 下面给出一个例子:

    在读C++primer的时候遇到了一句话让我很是费解:

    派生类只能通过派生类对象访问其基类的protected成员,派生类对其基类类型对象的protected成员没有特殊的访问权限。

    经查阅资料 个人理解是这样的:只有在派生类中的作用域中(譬如派生类中的函数)才可以通过派生类对象访问基类的protected成员,在派生类中也不可以直接访问基类对象的protected成员。

    下面给出一个例子:

    #include <iostream>
    #include <stdio.h>
    #include <string.h>
    using namespace std;
    
    class Item_base
    {
    private:
        string isbn;
    protected:
        double price;
    public:
        Item_base(const string & book = " ",double sale_price = 0.0,int data = 0)
                        :isbn(book),price(sale_price),data(data){}
    
        //返回书的名字
        string book()const {return isbn;}
        //返回价格,需在继承类中重新定义
        virtual double net_price(size_t n) const
                {return n* price; }
        //析构函数,一般基类的析构函数都为虚函数
        virtual ~Item_base() {}
        int data;
    };
    class Bulk_item:public Item_base
    {
    public:
        double net_price(size_t ) const;
        double memfcn(const Bulk_item &d,const Item_base &b);
    private:
        size_t min_qty;
        double discount;
    };
    double Bulk_item::net_price(size_t s) const
    {
        return s * price;
    }
    double Bulk_item::memfcn(const Bulk_item &d,const Item_base &b)
    {
        double ret = price; //这个也是相当于在派生类中通过派生类对象访问基类的protected 成员,是通过访问*this 这个派生类对象访问的,这里相当于 this->price
        ret = d.price;   //在派生类作用域范围内可以访问基类的protected成员
        //ret = b.price; // 基类的对象也不可以直接访问基类中protected成员
        return ret;
    }
    int main()
    {
        Bulk_item s;
        //cout << s.price << endl; //这样访问是错误的,不可以直接通过派生类对象访问基类protected成员。
        cout << s.data << endl;
        return 0;
    }


    如果一个基类没有派生类的话 :那么它有2种用户:

    1)类本身的成员(就是类本身的成员函数)//类成员和友元可以访问public 和private成员
    2)类的用户(就是类的对象)  //它只能访问public接口


    但是当有了继承,产生了第3类用户 派生类和派生类对象。在派生类的作用域范围内可以通过派生类对象访问对象的基类protected成员。提供给派生类的接口是protected成员和public成员的组合。


    C++中派生类对基类成员的访问形式主要有以下两种:
    1、类内部访问:由派生类中新增成员函数对基类继承来的成员的访问。(这个访问相当于通过this 指针访问 )
    2、类对象访问:在派生类外部,通过派生类的对象对从基类继承来的成员的访问。今天给大家介绍在3中继承方式下,派生类对基类成员的访问规则。


    下面看一下访问规则:

    1、公有继承的访问规则
    当类的继承方式为公有继承时,基类的public成员和protected成员被继承到派生类中仍作为派生类的public成员和protected成员,派生类的其它成员可以直接访问基类的public和protected成员,就好象这些成员是派生类自己的成员一样。但是,类的外部使用者只能通过派生类的对象访问继承来的public成员。基类的private成员在私有派生类中是不可直接访问的,所以无论是派生类成员还是派生类的对象,都无法直接访问从基类继承来的private成员,但是可以通过基类提供的public成员函数直接访问它们。公有继承的访问规则总结如下:


    基类成员

    private成员

    public成员

    protected成员

    内部访问

    不可访问

    可访问

    可访问

    对象访问

    不可访问

    可访问

    不可访问


    来我们写一个 程序来验证下上面的访问方式:

    #include <iostream>
    using namespace std;
    
    class Item_base
    {
    private:
        string isbn;
    protected:
        double price;
    public:
        Item_base(const string & book = " ",double sale_price = 0.0,int data = 0)
                        :isbn(book),price(sale_price),data(data){}
    
        //返回书的名字
        string book()const {return isbn;}
        //返回价格,需在继承类中重新定义
        virtual double net_price(size_t n) const
                {return n* price; }
        //析构函数,一般基类的析构函数都为虚函数
        virtual ~Item_base() {}
        int data;
    
    };
    class Bulk_item:public Item_base
    {
    public:
        double net_price(size_t ) const;
        double memfcn(const Bulk_item &d,const Item_base &b);
        void printData(){cout << data ;}        //可以直接访问基类的public成员
        void printIsbn(){cout << isbn ;}       //不可以直接访问基类的private成员
    private:
        size_t min_qty;
        double discount;
    };
    double Bulk_item::net_price(size_t s) const
    {
        return s * price;
    }
    double Bulk_item::memfcn(const Bulk_item &d,const Item_base &b)
    {
        double ret = price;             //内部访问基类protected成员,OK ,可以通过。
        ret = d.price;                  //在派生类作用域范围内可以访问基类的protected成员
        //ret = b.price;                // 基类的对象也不可以直接访问基类中protected成员
        // string s = isbn;
        return ret;
    }
    int main()
    {
        Bulk_item s;
        //cout << s.price << endl;      //对象访问基类 protected成员,不通过
        cout << s.data << endl;        // 对象访问基类public成员,可以通过
        cout << s.isbn << endl;        // 对象访问基类private成员,编译不通过
        s.print();
        return 0;
    }


    2、私有继承的访问规则
    当类的继承方式为私有继承时,基类的public成员和protected成员被继承后成为派生类的private成员,派生类的其它成员可以直接访问它们,但是在类的外部通过派生类的对象无法访问。基类的private成员在私有派生类中是不可直接访问的,所以无论是派生类的成员还是通过派生类的对象,都无法直接访问从基类继承来的private成员,但是可以通过基类提供的public成员函数间接访问。私有继承的访问规则总结如下:

    当类的继承方式为私有继承时,基类的public成员和protected成员被继承后成为派生类的private成员,派生类的其它成员可以直接访问它们,但是在类的外部通过派生类的对象无法访问。基类的private成员在私有派生类中是不可直接访问的,所以无论是派生类的成员还是通过派生类的对象,都无法直接访问从基类继承来的private成员,但是可以通过基类提供的public成员函数间接访问。私有继承的访问规则总结如下:

    基类成员

    private成员

    public成员

    protected成员

    内部访问

    不可访问

    可访问

    可访问

    对象访问

    不可访问

    不可访问

    不可访问

     


    展开全文
  • 派生类 不能通过 基类对象 访问 基类protected成员,如果能,不就成了public了吗? 所以“不仅派生类不能通过基类对象访问其protected成员,其他... 如果不派生类中,派生类对象就不可以访问基类protected成员。
  • 一、派生类 不能通过 基类对象 访问 基类protected成员 派生类 不能通过 基类对象 访问 基类protected成员,如果能,不就成了public了吗? 所以“不仅派生类不能通过基类对象访问其protected成员,其他类也不能...
  • 在基类定义了模板窗口,继承类中通过layout文件修改其中一个窗口的内容。 // 基类layout中定义了一个id为LCD的布局 RelativeLayout mLCD = (RelativeLayout) findViewById(R.id.LCD); // 基类layout中定义了...
  • 定义基类Base

    千次阅读 2015-05-23 12:25:09
    【6.13】定义基类Base,其数据成员为高h,定义成员函数...主函数中,用基类Base定义指针变量pc,然后用指针pc动态调用基类和派生类中虚函数disp,显示长方体与圆柱体的体积。 #include using namespace std; class Ba
  • C++ 虚基类定义、功能、规定

    千次阅读 2017-09-30 11:02:11
    虚继承和虚基类定义是非常的简单的,同时也是非常容易判断一个继承是否是虚继承的,虽然这两个概念的定义是非常的简单明确的,但是C++语言中虚继承作为一个比较生僻的但是又是绝对必要的组成部份而存在着,并且...
  • public、private和protected 继承 基类protected派生类的派生类,仍然可以访问基类 ...protected继承,派生类的对象可以类内访问基类的public和protected,并把基类的public和protected都变成protected...
  • #include<... protected: double x,y;//分别表示长方形的长和宽。 public: KB(double x1,double y1) { x=x1; y=y1; } virtual double area()//虚函数,计算长方形的面积,计算公式...
  • 定义基类和派生类

    2014-10-29 09:09:00
    定义基类 对于基类,我们需要记住的是作为继承关系中根节点的类通常都会定义一个虚析构函数。 基类通常都会定义一个虚析构函数,即使该函数不执行任何实际操作也是...C++语言中,基类必须将它的两种成员函数区...
  • Description: 定义基类和派生类 父类 Item_base <----- 子类 Bulk_item 基类: virtual函数 protected成员 派生类 类派生列表 重定义vietual函数 可以访问基类的public和...
  • 三、定义主从实体基类

    千次阅读 2008-11-19 15:39:00
    三、定义主从实体基类 定义主从实体基类的原因是我希望类的定义时,可以很明确的了解类之间的主从关系。 3.1定义主表基类 定义PrimaryDataEntityBase
  • C++ 定义基类和派生类

    千次阅读 2015-02-14 14:04:28
    一、基类 1、virtual 函数:可以被继承,被重写。如果不是virtual函数,不可以被重新,...2、重定义virtual函数 3、可以访问基类的public和procted成员   继承方式\成员类型 public protected private public pu
  • 1.定义一抽象类Pet(宠物)类,作为基类。 2.类中定义两个私有字段毛色和年龄,定义抽象方法完成宠物的自我介绍功能; 3.定义两个派生类Cat和Dog,再覆写基类抽象方法; 4.定义包含主方法的类MainClass,通过抽象类...
  • 《c++primer第四版中文》中p579,对“派生类到基类转换的可访问性”讲的比较模糊,于是用visual studio 2008花了四个小时把大部分能想到的情况都试验了一下,得出如下结果。 这里的后代类指的是由基类派生的派生...
  • 实验6.3 定义一个车(vehicle)基类(虚基类

    千次阅读 多人点赞 2020-06-08 17:46:28
    定义一个车(vehicle)基类,具有MaxSpeed、Weight等成员变量,Run、Stop等成员函数,由此派生出自行车(bicycle)类、汽车(motorcar)类。自行车(bicycle)类有高度(Height)等属性,汽车(motorcar)类有座位数...
  • Private私有派生或Protected保护派生时,如何让基类方法派生类外面可用 方法1:定义一个使用该基类方法的派生类方法 Student:private valarray Student类想使用valarray类的sum()方法 则可以: double ...
  • //虚拟函数:在基类中被声明为virtual,而派生类中又重新定义了这个函数#includeclass base{public: virtual void f1() { cout } virtual void f2() { cout } virtual void f3()
  • 1、定义Controller基类 2、日期处理工具类 3、sql操作工具类 4、引入分页插件依赖 5、返回表格分页数据对象 6、表格数据处理 1、定义Controller基类 package com.ruoyi.framework.web.controller; /** * ...
  • 15.2基类与派生类的定义

    千次阅读 2011-10-10 12:29:32
    动态绑定 C++中,通过基类的引用/指针调用虚函数时,发生动态绑定。 基类的引用或指针既可以...用引用或指针调用的虚函数运行时确定,被调用的函数是引用或指针当前所指对象的实际类型所定义的。 访问控制 pu
  • C++中继承机制的繁复和微妙让作为初学者的我感觉头痛,下面对基类中public/private/protected成员的访问方式做一个总结。例子来自Primer C++ 中的书店购书的管理系统。 基类: class Item_base { public: Item_base...
  • 下面是一个典型ATL风格的类定义: #include "stdafx.h" #include "iostream.h" template class B1 { public: void SayHi() { T* pT = static_cast(this); pT->PrintClassName(); } protected:

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 95,636
精华内容 38,254
关键字:

在基类定义的protected