c 中protected（c#类的默认类型是protected还是private还是其它）

本文目录

• c#类的默认类型是protected还是private还是其它
• c++题目，最好带注释
• C++中 class的意思
• C++中 private和public的区别
• C# private和protected区别

c#类的默认类型是protected还是private还是其它

默认是internal ：
C#用多种修饰符来表达类的不同性质。根据其保护级C#的类有五种不同的限制修饰符：
public可以被任意存取；
protected只可以被本类和其继承子类存取；
internal只可以被本组合体（Assembly）内所有的类存取，组合体是C#语言中类被组合后的逻辑单位和物理单位，其编译后的文件扩展名往往是“.DLL”或“.EXE”。
protected internal唯一的一种组合限制修饰符，它只可以被本组合体内所有的类和这些类的继承子类所存取。
private只可以被本类所存取。
如果不是嵌套的类，命名空间或编译单元内的类只有public和internal两种修饰。
new修饰符只能用于嵌套的类，表示对继承父类同名类型的隐藏。
abstract用来修饰抽象类，表示该类只能作为父类被用于继承，而不能进行对象实例化。抽象类可以包含抽象的成员，但这并非必须。abstract不能和new同时用。下面是抽象类用法的伪码：
abstract class A
{
public abstract void F();
}
abstract class B: A
{
public void G() {}
}
class C: B
{
public override void F()
{
//方法F的实现
}
}
抽象类A内含一个抽象方法F()，它不能被实例化。类B继承自类A，其内包含了一个实例方法G(),但并没有实现抽象方法F()，所以仍然必须声明为抽象类。类C继承自类B，实现类抽象方法F()，于是可以进行对象实例化。
sealed用来修饰类为密封类，阻止该类被继承。同时对一个类作abstract和sealed的修饰是没有意义的，也是被禁止的。

c++题目，最好带注释

#include 《iostream》
using namespace std;
class CTime{
protected:
int hour;
int minute;
int second;
public:
//无参构造函数
CTime(){
this-》hour = 0;
this-》minute = 0;
this-》second = 0;
//cout《《"CTime()"《《endl;//
}
//带参构造函数
CTime(int hour, int minute, int second){
this-》hour = hour;
this-》minute = minute;
this-》second = second;
//cout《《"CTime(...)"《《endl;//
}
//copy构造函数
CTime(const CTime& CT){
this-》hour = CT.hour;
this-》minute = CT.minute;
this-》second = CT.second;
//cout《《"CTime(&)"《《endl;//
}
//打印时间
void prtTime(){
cout《《this-》hour《《":"《《this-》minute《《":"《《this-》second;
}
//检查时间有效性
bool timeValidate(int hour, int minute, int second){
if(hour 《 0 || hour 》 23)//时间没有24:00
return false;
if(minute 《 0 || minute 》 59)
return false;
if(second 《 0 || second 》 59)
return false;
return true;
}
//修改时间函数
void setTime(int hour, int minute, int second){
//如果设置时间有效
if(timeValidate(hour, minute, second) == true){
this-》hour = hour;
this-》minute = minute;
this-》second = second;
}else{
cout《《"输入日期无效"《《endl;//
}
}
};
class CDate{
protected:
int year;
int month;
int day;
public:
//无参构造函数
CDate(){
this-》year = 0;
this-》month = 0;
this-》day = 0;
//cout《《"CDate()"《《endl;//
}
//带参构造函数
CDate(int year, int month, int day){
this-》year = year;
this-》month = month;
this-》day = day;
//cout《《"CDate(...)"《《endl;//
}
//copy构造函数
CDate(const CDate &CD){
this-》year = CD.year;
this-》month = CD.month;
this-》day = CD.day;
//cout《《"CDate(&)"《《endl;//
}
//判断是否为闰年
bool isLeap(){
if(this-》year % 4 == 0 && this-》year % 100 != 0 || this-》year % 400 == 0)
return true;
return false;
}
//打印日期
void prtDate(){
cout《《this-》year《《"-"《《this-》month《《"-"《《this-》day;
}
//检查日期有效性
bool dateValidate(int year, int month, int day){
if(year 《 0)
return false;
if(month 《 1 || month 》 12)
return false;
if(1== month ||3 == month ||5 == month ||7 == month ||8 == month ||10 == month ||12 == month)
if(day 《 1 || day 》 31)
return false;
if(4== month ||6 == month ||9 == month ||11 == month)
if(day 《 1 || day 》 30)
return false;
if(2 == month){
if(isLeap()){
if (day 《 1 || day 》 29)
return false;
}else if(day 《 1 || day 》 28)
return false;
}
return true;
}
//修改时间函数
void setDate(int year, int month, int day){
//如果设置日期有效
if(dateValidate(year, month, day) == true){
this-》year = year;
this-》month = month;
this-》day = day;
}else{
cout《《"输入日期无效"《《endl;//
}
}
};
class CTimeDate:public CTime, public CDate{
public:
CTimeDate(){
}
CTimeDate(int year, int month, int day, int hour, int minute, int second)
:CDate(year, month, day), CTime(hour, minute, second){
}
CTimeDate(const CTimeDate &CTD):CDate(CTD), CTime(CTD){
}
//打印时间日期
void prtDateTime(){
prtDate();
cout《《" ";
prtTime();
cout《《endl;
}
//判断当前时间是否有效
bool isVaidate(){
return timeValidate(this-》hour, this-》minute, this-》second) && 
dateValidate(this-》year, this-》month, this-》day);
}
};
int main(){
//测试无参构造函数==============================
CTimeDate CTD1;
CTD1.prtDateTime();
//测试有参构造函数==============================
CTimeDate CTD2(2014, 11, 28, 17, 34, 45);
CTD2.prtDateTime();
//测试copy构造函数==============================
CTimeDate CTD3(CTD2);
CTD2.prtDateTime();
//测试是否为闰年==============================
if(CTD2.isLeap() == true)
cout《《"2014是闰年"《《endl;
else
cout《《"2014不是闰年"《《endl;
//测试set函数
CTD2.setDate(2000, 10, 1);
CTD2.setTime(12, 11, 1);
CTD2.prtDateTime();
//测试是否为闰年==============================
if(CTD2.isLeap() == true)
cout《《"2000是闰年"《《endl;
else
cout《《"2000不是闰年"《《endl;
//测试日期是否有效==============================
CTD2.setDate(2000, 9, 31);
CTD2.setTime(12, 11, 31);
return 0;
}

执行结果:

C++中 class的意思

C++中的class是C++不同于C的关键所在；
是面向对象中声明的类；
类是一组数据和对这些数据的操作（函数）的封装；
类中还可有访问的权限的控制
其中private只能由本类中的成员函数访问；
public可以由类外的成员函数访问；
protected是受保护的数据成员，在他的子类中（从此类继承产生的类）protected相当于private也就是其子类的成员函数可以访问，而其他的类中的成员函数不能访问；

C++中 private和public的区别

C++中 private和public的区别？

private和public的作用是让编译器帮你检查某些模组是否使用了他没许可权使用的模组，也就是生成可执行程式码的时候做许可权检查。比如，公司里各个部门有自己私有的资讯，财务部可以看所有员工工资，而销售部不可以，普通员工也不可以。
可不可以访问都是认为规定的，而且在写程式码的时候程式是不会执行的，因此需要在生成程式码的时候做一些检查，就像语法错误在编译的时候被检查出来一样，因为人规定了程式码该如何写。访问控制也是在编译的时候检查，c++采用了private，public，protected，以及friend来限制访问许可权。
private的意思是指类的内部变数或者函式是私有的，在类之外包括继承类就不可见，像魔术师的道具；public是指类的内部变数是外部可见的，像魔术师的表演；protected是指除了本类和继承类之外不可见，像魔术师希望徒弟使用道具，就得让其徒弟看见道具，但是是一种受保护的许可权；friend是指特定指出哪些类或者模组可以看见本类的私有（private以及protected）成员，这就是魔术师信得过的朋友可以让他看见一些幕后。
使用好这个规则，只要程式中出现了越权访问的程式码，编译的时候就会被检查出来，以保证安全。
举例：
class moshushi魔术师类
{
friend class daoyan;导演可以知道魔术师背后的秘密
public:所有人都可以看见的行为以及物品
int jinchang();进场
int biaoyan();表演
int tuichang();退场
int shou, yifu, maozi;手，衣服，帽子
protected:徒弟可以知道的
int zhaotuo();找个托
int gangsi;钢丝
private:只有自己和friend可以知道
int zuobi();作弊
int yaoshui, tezhizhuozi;药水，特制桌子
};
class tudi: public moshushi魔术师徒弟
{
自动有了魔术师的public以及protected
};
class daoyan导演
{
int func(){
可以访问到魔术师物件的私有域
}
...
};
class guanzhong观众
{
不能访问魔术师物件的私有域
...
};

求C++类型别Class中public和private的区别

public 表示资料成员，成员函式可以被其它类或子类访问
private表示只有当前类内部可以访问

C++中public、private和protected访问属性的区别

在本类中，protected与private是相同的，但protected可以被继承，而private却不行。 只有公有成员才能在类的外部访问。如class A{private:int a;public:int b;protected:int c;};A ca;ca.a error ca.b ok ca.c error cb.c error。虽然c也是B的成员，但c在被继承的时候变成私有或者受保护的成员了。

c++类中public,private,protected的用法与区别。

protected型别的访问机制与private一样
在基类的派生类中,可以直接访问继承而来的protected成员,但是不能访问private限制的成员.所以在派生类中,可以访问基类继承而来的public和proected两种型别的成员.
在public公有派生下,继承而来的成员访问许可权不变.protected派生下,public和protected都变成protected,private派生下,所有的继承下来都是private了

C++中型别定义中的public与 private的区别

public,可以夸函式呼叫；而private，只能局限于同函式内的其他成员呼叫与使用。

java中private和public的区别

作用域 当前类 同一package 子孙类 其他package
public √ √ √ √
private √ × × ×

在JAVA中，public和private的区别？

公共和私有，公共的（变数、方法）在这个类外还能呼叫，私有的只能在类（class）内部使用。

private 和public 的区别

private 只能是自己的类访问 。

1、public：public表明该资料成员、成员函式是对所有使用者开放的，所有使用者都可以直接进行呼叫
2、private：private表示私有，私有的意思就是除了class自己之外，任何人都不可以直接使用，私有财产神圣不可侵犯嘛，即便是子女，朋友，都不可以使用。

public和private的区别

private，标识只有在当前物件可以用，public表示外面也可以用
例如：
public class User（）{
private userId;
public username;
}
User u = new User（）；
这时你只能访问u.username.private的userId是不能被访问的

C# private和protected区别

private只有内部可以看到，并且只能内部调用。
而Protected虽然可以被外界看到，但外界却不能调用。
按字面意思，前者是我私有的，在口袋里放着，比如说一颗很大的钻石，照耀于世当然很危险；后者是受保护的，虽然你看见我手里拿着个手机，你却不敢抢去用。因为那时不合理法的，并且被看到了也没什么。
差不多就这个意思了。
选择用那个，你就看看这个东西是钻石还是手机。