⑴ C#中用private声明一个类是什么意思
private 是修饰符
它和protected, public一起,都是对类的访问权限进行修饰,或者说是限制,
private，只有类内可直接访问，
partial关键字的作用是将你的 class 分为多个部分，编译器会将多个部分拼到一起去。
例子:
public partial class SampleClass
{
public void MethodA()
{
}
}
public partial class SampleClass
{
public void MethodB()
{
}
}
和
public class SampleClass
{
public void MethodA()
{
}
public void MethodB()
{
}
}
是等价的.
⑵ 和用class声明一个类，有什么区别
类的声明只是告诉编译器有这么一个类，它的名字是XXX，它具有哪些成员函数，哪些成员变量；而定义类是通过实例化类，对其分配存储空间。声明和定义最大的分别是是否分配存储空间。 例如，这是类的声明： class Student { public： 公用的数据和成员函数 protected： 保护的数据和成员函数 private： 私有的数据和成员函数 };//摘自网络 这是定义类：Student A = new Student（）；//分配了存储空
⑶ java中函数的声明和定义
Java中，我们应该知道最基本的就是定义变量和声明变量了，那么定义与声明这两者有没有区别呢?具体的区别又是哪些呢?下面学习啦小编来告诉你定义与声明的区别。
定义和声明的定义区别
1、一种是需要建立存储空间的。例如：int a 在声明的时候就已经建立了存储空间。
2、另一种是不需要建立存储空间的。 例如：extern int a 其中变量a是在别的文件中定义的。
声明是向编译器介绍名字--标识符。它告诉编译器“这个函数或变量在某处可找到，它的模样象什么”。
而定义是说：“在这里建立变量”或“在这里建立函数”。它为名字分配存储空间。无论定义的是函数还是变量，编译器都要为它们在定义点分配存储空间。
对于变量，编译器确定变量的大小，然后在内存中开辟空间来保存其数据，对于函数，编译器会生成代码，这些代码最终也要占用一定的内存。
总之就是：把建立空间的声明成为“定义”，把不需要建立存储空间的成为“声明”。
基本类型变量的声明和定义(初始化)是同时产生的;而对于对象来说，声明和定义是分开的。
下面小编给大家举个例子说明一下。
例如：类A
如果A a;就是一个声明，告诉编译器a是A类的一个对象变量，但是不进行初始化;
如果以后a=new A();这就是初始化，分配了空间。
需要注意的是我们声明的最终目的是为了提前使用，即在定义之前使用，如果不需要提前使用就没有单独声明的必要，变量是如此，函数也是如此，所以声明不会分配存储空间，只有定义时才会分配存储空间。
用static来声明一个变量的作用有二：
(1)对于局部变量用static声明，则是为该变量分配的空间在整个程序的执行期内都始终存在。
(2)外部变量用static来声明，则该变量的作用只限于本文件模块。
定义和声明的具体区别
所谓定义就是(编译器)创建一个对象，为这个对象分配一块内存，并给它取上一个名字，这个名字就是就是我们经常所说的变量名或对象名。
声明有2重含义：
(1) 告诉编译器，这个名字已经匹配到一块内存上，下面的代码用到变量或者对象是在别的地方定义的。声明可以出现多次。
(2) 告诉编译器，这个名字已经被预定了，别的地方再也不能用它来作为变量名或对象名。
定义和声明最重要区别
定义创建对象并为这个对象分配了内存，声明没有分配内存。
⑷ 如何区分C++中类的声明和定义
如果是指变量的声明和定义：
从编译原理上来说，声明是仅仅告诉编译器，有个某类型的变量会被使用，但是编译器并不会为它分配任何内存。而定义就是分配了内存。
对于下面的两句代码：
void Func()
{
int a;
int b=1;
a=0;
}
对于第一行代码，编译器不会做任何事，它不会为它在栈中分配一点东西，直到第三句，a=0;时，编译器才会将其压入栈中。而对于int b=0;这一句，编译器就会生成一条指令，为它赋值。如果反汇编，看到的代码可能是这样的：
push 1;
push 0;
当然，并不一定编译器就会样做，也有可能在声明int a时，编译器就会把一个废值入栈，到第三条再为其赋值，这要看编译器的具体取舍，所以，声明不一定不是定义，而定义一定是定义。
但是，下面的声明，一定仅仅是声明：
extern int a;
这表时，有一个int变量a，它一定是在另外其他地方定义的，所以编译器此时一定不会做什么分配内存的事，因为它就是声明，仅仅表明下面的代码引用了一个符号，而这个符号是int类型的a而已。
如果是指函数的声明和定义：
声明：一般在头文件里，对编译器说：这里我有一个函数叫function() 让编译器知道这个函数的存在。
定义：一般在源文件里，具体就是函数的实现过程 写明函数体。
⑸ 如何声明类何为实例化
可以声明一个类而不定义它
class Screen;//declaration of the Screen class
这个声明,有时候被称为前向声明(forward declaration),在程序中引入了类类型的Screen.在声明之后,定义之前,类Screen是一个不完全类型(incompete type),即已知Screen是一个类型,但不知道包含哪些成员.
不完全类型只能以有限方式使用,不能定义该类型的对象,不完全类型只能用于定义指向该类型的指针及引用,或者用于声明(而不是定义)使用该类型作为形参类型或返回类型的函数.
对于C++中，类的定义之前声明它，如下实例代码：
class B;
class A{
//..............................
B * ptr_B;.
};
class B{
//....................
};
被提前声明的类在其定义之前，只能使用该类的指针或者引用 。
在类的定义结束(编译器在遇到类定义的右花括号之后),用该类来声明类实例对象,或对象指针,引用都是合法的。
前向声明
超前引用
所谓超前引用是指一个类型在定义之前就被用来定义变量和声明函数。
一般情况下，C/C++要求所有的类型必须在使用前被定义，但是在一些特殊情况下，这种要求无法满足，
例如，在类CMyView中保留了一个非模式对话框对象指针，该对象用于显示/修改一些信息。为了实现对话框
“应用”按钮，把对话框做的修改立刻更新到view界面上，为此，需要在对话框类中需要保存view类的指针，这样
定义关系就变成如下的代码：
#ifndef __MYVIEW_H__
#define __MYVIEW_H__
//这是view类的头函数
#include "MyDialog.h"
class CMyView::public CView
{
protected:
CMyDialog * pDlg;
//这里是其他定义
};
#endif
#ifndef __MYDIALOG_H__
#define __MYDIALOG_H__
//这是对话框类的定义
#include "MyView.h"
class CMyDialog::public CDialog
{
protected:
CMyView * pView;
//其他定义
};
#endif
从编译器角度看，编译MyDialog.CPP时，系统首先定义宏__MYDIALOG_H__，然后包含MyView.h，MyView.h中
的#include "MyDialog.h"由于__MYDIALOG_H__已经定义，所以不再起作用。在CMyView类的声明中，
CMyDialog* pDlg ;
就会让编译器产生“CMyDialog"类型没有定义之类的错误，编译MyView.CPP文件出现的错误可以类似得到。
更一般的情况，类A和类B需要彼此互相引用，这样必然有一个类会先被定义，而另外一个类后被定义，这样在
先被定义的类引用后被定义的类的时候，就导致了所谓的超前引用。
超前引用导致的错误有以下几种处理办法：
1) 使用类声明
在超前引用一个类之前，首先用一个特殊的语句说明该标识符是一个类名，即将被超前引用。其使用方法是：
a) 用class ClassB；声明即将超前引用的类名
b) 定义class ClassA
c) 定义class ClassB;
d) 编制两个类的实现代码。
上述方法适用于所有代码在同一个文件中，一般情况下，ClassA和ClassB分别有自己的头文件和cpp文件，这种
方法需要演变成：
a) 分别定义ClassA和ClassB，并在cpp文件中实现之
b) 在两个头文件的开头分别用class ClassB;和class ClassA;声明对方
c) 在两个cpp文件中分别包含另外一个类的头文件
NOTE:这种方法切记不可使用类名来定义变量和函数的变量参数，只可用来定义引用或者指针。
2) 使用全局变量
由于全局变量可以避免超前引用，不用赘述。我的习惯是，把类对象的extern语句加在该类头文件的最后，大家喜欢
怎样写那都没有什么大问题，关键是保证不要在头文件中胡乱包含。
3) 使用基类指针。
这种方法是在引用超前引用类的地方一律用基类指针。而一般情况下，两个互相引用的类并不涉及其基类，因此不会造成
超前引用。以开始的例子说：在CMyDialog类中用CView*代替CMyView*，在CMyView类中用CDialog*代替CMyDialog*，这样必然
不会造成超前引用。
说明：本文中，为了叙述方便，把class AClass;语句成为类AClass的声明，把class AClass开始的对AClass的类成员变量、
成员函数原型等的说明称为类的定义，而把在CPP中的部分称为类的定义。如果大家对这三个词有不同的理解，请按照自己的本意
把这三个词换成相应的词来理解。
⑹ C++ 包括类的声明、成员函数的实现
虽然很多程序员都熟悉名字空间的概念，但他们常常都是被动地使用名字空间。也就是说他们使用的是第三方定义的成员（如标准库的类和函数），而不是在名字空间中声明自己的类和函数。本文拟讨论如何在名字空间中声明自己的类和函数，以及如何在程序中使用它们。
名字空间是一个范畴，它包含类声明，函数声明，常量声明和模板声明等名字空间成员。例如：
namespace proj_alpha
{
//下面是名字空间 proj_alpha 的成员
class Spy {/*..*/};
void encrypt (char *msg);
const int MAX_SPIES = 8;
}
在上面的例子中，类Spy在一个单独的文件中实现。通常，你是在一个专门的头文件中声明一个类并在不同的源文件中独立地定义其成员函数。那么如何将名字空间成员类分离成多个源文件呢？
下面是名为 Foo.hpp 的头文件，其中定义了一个名为NS的名字空间，它包含类Foo的声明：
//Foo.hpp
namespace NS
{
class Foo
{
public:
void f();
void g();
};
}//close NS
另外，在一个单独的源文件Foo.cpp中，首先包含头文件Foo.hpp以便实现类Foo的成员函数f()和g()：
//Foo.cpp
#include "Foo.hpp"
void NS::Foo::f()
{ /*..*/ }
void NS::Foo::g()
{ /*..*/ }
为了使用名字空间成员，必须使用成员的全路径名，它由名字空间后跟::合成原名组成。因此，类Foo的全路径名是NS::Foo。这样编译器便可以知道NS是一个名字空间名，头文件Foo.hpp必须在引用NS之前被包含。
名字空间是可以扩展的。也就是说可以声明类，而且所声明的类在其它的.cpp文件中是相同的名字空间成员：
//Bar.hpp
namespace NS //扩展 NS
{
class Bar
{
public:
void a();
void b();
};
}
在Bar.cpp文件中：
#include "Bar.hpp"
void NS::Bar::a()
{/*..*/}
void NS::Bar::b()
{/*..*/}
可以看出，虽然Foo和Bar这两个类在不同的头文件中声明，但它们都是名字空间NS的成员。并且编译器和链接器将这两个类看成是同一名字空间的成员。那么，如何在应用程序中使用这些类呢？
在文件main.cpp中，必须要包含声明类Foo和Bar的头文件并加上相应的名字空间引用声明-using：
#include "Bar.hpp"
#include "Foo.hpp"
int main()
{
using NS::Bar; //使用名字空间
using NS::Foo; //同上
Bar b;
Foo f;
f.f();
//...
}
using声明由关键字using后跟名字空间成员的全路径。这样就使你在using声明范围内使用成员时不用再加路径。上面的例子中，可以直接使用Foo和Bar，因为在main()的开始使用了using声明。如果没有using声明就必须使用全路径成员名。
int main()
{
NS::Bar b; //全路径名
NS::Foo f; //同上
//?
}
另外，还有一种引用名字空间成员的方法是使用using指令：
#include "Bar.hpp"
#include "Foo.hpp"
int main()
{
using namespace NS; // using 指令
Bar b;
Foo f;
f.f();
//...
}
using指令由关键字“using namespace”后跟名字空间名构成。在访问名字空间成员时它是使用最少的一种方法，原因是这种方法将所有名字空间成员注入当前的范围，从而增加了潜在的名字冲突。
⑺ c++中类的前向声明.
在编译时，编译器必须知道每个类型的size，class a嵌套定义b p;但编译器不知道p的大小，所以无法编译。通过指针就可以了。
⑻ 发现一个声明一个类的时候，比如role myrole和role myrole=null这两种声明是有区别的，请问具体区别
第一一个是全局变量的声明才可以用，当然也可以用第二个，全局变量声明用第一个时会默认给个初值，也就是第二个的情况。局部变量申明只能用第二个，其实没有为什么，是编译器的默认，记得这么使用就可以了。
⑼ C/C++中struct，typedef声明的“过程”问题。
指针是两个变量，一个是指针本身，一个是指向的对象。
你声明结构体的时候里面有个指针，不管指什么，实例化的时候总能够开辟出内存来，指针就是4字节，指针前面的类型在声明的时候没有什么用，只有在解引用的时候才有用，所以声明的时候指不指向自身没有区别。但是不能定义该类的对象，类还没有定义就有了类对象，这不合逻辑，然后也没法开辟内存。
其他的就是基础，要声明某个类型的变量，你得事先告诉编译器有这个类型。