什么是类的成员函数和非成员函数?
在类定义时候大括号里面写的函数是成员函数，其他的就是非成员函数，希望对你有帮助！
请问什么是成员函数的定义？
成员函数相当于C或C++中的函数。你应该用如下的方式说明一个成员函数：
Type name (Parameter)
//function body
注意：每一个成员函数必须返回一个值或声明返回为空(void)。它返回类型的说明告诉编译器它将返回什么类型的值。在某些情况下，成员函数需要表示它是否成功的完成了它的工作，此时返回类型通常为布尔型的。参数表是用逗号分开的一组变量，它将为成员函数提供所需信息。
下面例子中定义了一个成员函数。通过它，你的矩形类可以计算自己的面积了：
int getArea(int w,int h)
{
int a;
a=w*h;
return a;
}
另外，矩形还需要对自己进行描绘，因此它需要成员函数drawRect()，此时，你的矩形类的定义将如下所示：
public class DrwRect
{
public static void main(String args[])
{
class Rectangle
{
int width,height,area;
public Rectangle(int w,int h)
{
width=w;
height=h;
area=getArea(w,h);
}
protected int getArea(int w,int h)
{
int a;
a=w*h;
return a;
}
public void drawRect()
{
int i,j;
for(i=width;i>0;i--)
System.out.print("#");
System.out.print("") ;
for(i=height-2;i>0;i--)
System.out.print("#");
for(j=width-2;i>0;j--)
System.out.print("");
System.out.print("#");
for(i=width;i>0;i--)
System.out.print("#");
System.out.print("");
}
} //Rectangle
int w=Integer.valueOf(args[0]).intValue();
int h=Integer.valueOf(args[1]).intValue();
Rectangle myrect=new Rectangle(w,h);
myrect.drawRect();
}
}
上例中最后一个“#”号后面还有一个System.out.print("")这是由于这个成员函数在上一行没有结束而且缓冲区没有溢出时将不把输出结果写屏。若你使用print成员函数，却没有得到输出，这时仔细确认一下你是否以""来结束你的输出流。
2：不同类型的成员函数
在上例的成员函数声明中你需要注意两点：getArea()定义为private型，drawRect()定义为public型。public型意味着任何类都可以调用它。private型，它只能被所声明的类内部调用。这些说明类型同样适用于数据变量。
若有人想改变一个私有变量，通常要引用下面的成员函数：
public void setWidth(int w)
{
width=w;
}
注意：在Java中，protected只是作为关键字出现，而没有相应的功能。
3：成员函数的重载
假如你必须在不同情况下发送不同的信息给同一个成员函数的话，该怎么办呢？你可以通过对此成员函数说明多个版本（version）的方法来实现重载。重载的本质是创建了一个新的成员函数：你只需给它一个不同的参数列表（parameterlist），如下例所示：
void get Area(int w,int h);
void get Area(float w,float h);
在第二种情况下，成员函数get Area()接受两个浮点变量作为它的参数，编译器根据调用时的不同参数来决定该调用哪一种成员函数，假如你把两个整数提供给成员函数，你就调用第一个成员函数；假如你把两个浮点数提供给成员函数，第二个成员函数就被调用。
4：静态成员
除了public、private和protected以外，你还可以把成员说明为static(静态)。static修饰符表明一个变量或成员函数对所有类的实例都是相同的，你也许想使用一个所有Rectangle类都可以使用的变量，来说明该类的版本（version），假如你把它说明成一个static，那么该变量将对该类的所有实例都是一样的，如：
static int version=1;
静态成员函数和静态变量的优点就在于他们能在没有创建类的任何一个实例的情况下被引用，引用时在“.”域前，可直接使用类名而无须使用对象名。例如，drawRect成员函数使用了System.out.println成员函数，但实际上你却未曾创建一个某个System类的对象，这正是因为out是System类的一个静态变量，所以你可以直接使用这个成员函数而无须定义一个System对象。
5：构造和析构成员函数
类有一个特殊的成员函数叫做构造成员函数，它通常用于初始化类的数据成员。在创建对象时，会自动调用类的构造成员函数。Java中的构造成员函数必须与该类具有相同的名字，另外，构造成员函数一般都应用public类型来说明，这样才能在程序任意的位置创建类的实例－－对象。
下面是一个Rectangle类的构造成员函数，它带有两个参数，分别表示矩形的长和宽：
public Rectangle(int w,int h)
{
width=w;
height=h;
area=getArea(w,h);
}
除了构造成员函数以外，类还提供了析构成员函数，当对象被从内存中删除时，该成员函数将会被自动调用。通常，在析构成员函数内，你可以填写用来回收对象内部的动态空间的代码。
什么叫成员函数？有什么作用？
什么是友元（friend）？
允许另一个类或函数访问你的类的东西。
友元可以是函数或者是其他的类。类授予它的友元特别的访问权。通常同一个开发者会出于技术和非技术的原因，控制类的友元和成员函数（否则当你想更新你的类时，还要征得其它部分的拥有者的同意）。
分清成员函数，非成员函数和友元函数
成员函数和非成员函数最大的区别在于成员函数可以是虚拟的而非成员函数不行。所以，如果有个函数必须进行动态绑定（见条款38），就要采用虚拟函数，而虚拟函数必定是某个类的成员函数。关于这一点就这么简单。如果函数不必是虚拟的，情况就稍微复杂一点。
看下面表示有理数的一个类：
class rational {
public:
rational(int numerator = 0, int denominator = 1);
int numerator() const;
int denominator() const;
private:
...
};
这是一个没有一点用处的类。（用条款18的术语来说，接口的确最小，但远不够完整。）所以，要对它增加加，减，乘等算术操作支持，但是，该用成员函数还是非成员函数，或者，非成员的友元函数来实现呢？
当拿不定主意的时候，用面向对象的方法来考虑！有理数的乘法是和rational类相联系的，所以，写一个成员函数把这个操作包到类中。
class rational {
public:
...
const rational operator*(const rational& rhs) const;
};
（如果你不明白为什么这个函数以这种方式声明——返回一个const值而取一个const的引用作为它的参数——参考条款21-23。）
现在可以很容易地对有理数进行乘法操作：
rational oneeighth(1, 8);
rational onehalf(1, 2);
rational result = onehalf * oneeighth; // 运行良好
result = result * oneeighth; // 运行良好
但不要满足，还要支持混合类型操作，比如，rational要能和int相乘。但当写下下面的代码时，只有一半工作：
result = onehalf * 2; // 运行良好
result = 2 * onehalf; // 出错!
这是一个不好的苗头。记得吗？乘法要满足交换律。
如果用下面的等价函数形式重写上面的两个例子，问题的原因就很明显了：
result = onehalf.operator*(2); // 运行良好
result = 2.operator*(onehalf); // 出错!
对象onehalf是一个包含operator*函数的类的实例，所以编译器调用了那个函数。而整数2没有相应的类，所以没有operator*成员函数。编译器还会去搜索一个可以象下面这样调用的非成员的operator*函数（即，在某个可见的名字空间里的operator*函数或全局的operator*函数）：
result = operator*(2, onehalf); // 错误!
但没有这样一个参数为int和rational的非成员operator*函数，所以搜索失败。
再看看那个成功的调用。它的第二参数是整数2，然而rational::operator*期望的参数却是rational对象。怎么回事？为什么2在一个地方可以工作而另一个地方不行？
秘密在于隐式类型转换。编译器知道传的值是int而函数需要的是rational，但它也同时知道调用rational的构造函数将int转换成一个合适的rational，所以才有上面成功的调用（见条款m19）。换句话说，编译器处理这个调用时的情形类似下面这样：
const rational temp(2); // 从2产生一个临时
// rational对象
result = onehalf * temp; // 同onehalf.operator*(temp);
当然，只有所涉及的构造函数没有声明为explicit的情况下才会这样，因为explicit构造函数不能用于隐式转换，这正是explicit的含义。如果rational象下面这样定义：
class rational {
public:
explicit rational(int numerator = 0, // 此构造函数为
int denominator = 1); // explicit
...
const rational operator*(const rational& rhs) const;
...
};
那么，下面的语句都不能通过编译：
result = onehalf * 2; // 错误!
result = 2 * onehalf; // 错误!
这不会为混合运算提供支持，但至少两条语句的行为一致了。
然而，我们刚才研究的这个类是要设计成可以允许固定类型到rational的隐式转换的——这就是为什么rational的构造函数没有声明为explicit的原因。这样，编译器将执行必要的隐式转换使上面result的第一个赋值语句通过编译。实际上，如果需要的话，编译器会对每个函数的每个参数执行这种隐式类型转换。但它只对函数参数表中列出的参数进行转换，决不会对成员函数所在的对象（即，成员函数中的*this指针所对应的对象）进行转换。这就是为什么这个语句可以工作：
result = onehalf.operator*(2); // converts int -> rational
而这个语句不行：
result = 2.operator*(onehalf); // 不会转换
// int -> rational
第一种情形操作的是列在函数声明中的一个参数，而第二种情形不是。
尽管如此，你可能还是想支持混合型的算术操作，而实现的方法现在应该清楚了：使operator*成为一个非成员函数，从而允许编译器对所有的参数执行隐式类型转换：
class rational {
... // contains no operator*
};
// 在全局或某一名字空间声明，
// 参见条款m20了解为什么要这么做
const rational operator*(const rational& lhs,
const rational& rhs)
{
return rational(lhs.numerator() * rhs.numerator(),
lhs.denominator() * rhs.denominator());
}
rational onefourth(1, 4);
rational result;
result = onefourth * 2; // 工作良好
result = 2 * onefourth; // 万岁, 它也工作了!
这当然是一个完美的结局，但还有一个担心：operator*应该成为rational类的友元吗？
这种情况下，答案是不必要。因为operator*可以完全通过类的公有（public）接口来实现。上面的代码就是这么做的。只要能避免使用友元函数就要避免，因为，和现实生活中差不多，友元（朋友）带来的麻烦往往比它（他/她）对你的帮助多。
然而，很多情况下，不是成员的函数从概念上说也可能是类接口的一部分，它们需要访问类的非公有成员的情况也不少。
让我们回头再来看看本书那个主要的例子，string类。如果想重载operator>>和operator<<来读写string对象，你会很快发现它们不能是成员函数。如果是成员函数的话，调用它们时就必须把string对象放在它们的左边：
// 一个不正确地将operator>>和
// operator<<作为成员函数的类
class string {
public:
string(const char *value);
...
istream& operator>>(istream& input);
ostream& operator<<(ostream& output);
private:
char *data;
};
string s;
s >> cin; // 合法, 但
// 有违常规
s << cout; // 同上
这会把别人弄糊涂。所以这些函数不能是成员函数。注意这种情况和前面的不同。这里的目标是自然的调用语法，前面关心的是隐式类型转换。
所以，如果来设计这些函数，就象这样：
istream& operator>>(istream& input, string& string)
{
delete [] string.data;
read from input into some memory, and make string.data
point to it
return input;
}
ostream& operator<<(ostream& output,
const string& string)
{
return output << string.data;
}
注意上面两个函数都要访问string类的data成员，而这个成员是私有（private）的。但我们已经知道，这个函数一定要是非成员函数。这样，就别无选择了：需要访问非公有成员的非成员函数只能是类的友元函数。
本条款得出的结论如下。假设f是想正确声明的函数，c是和它相关的类：
·虚函数必须是成员函数。如果f必须是虚函数，就让它成为c的成员函数。
·operator>>和operator>或operator<<，让f成为非成员函数。如果f还需要访问c的非公有成员，让f成为c的友元函数。
·只有非成员函数对最左边的参数进行类型转换。如果f需要对最左边的参数进行类型转换，让f成为非成员函数。如果f还需要访问c的非公有成员，让f成为c的友元函数。
·其它情况下都声明为成员函数。如果以上情况都不是，让f成为c的成员函数。
回答者：Dyemn - 高级经理 六级 12-27 08:29
友元函数要在一个类体内说明,形式为:
friend 类型名 友元函数名(形参表);
然后在类体外对友元函数进行定义,定义的格式和普通函数相同,但可以通过对象作为参数直接访问对象的私有成员
友元函数说明如下:
1)必须在类的说明中说明友元函数,说明时以关键字friend开头,后跟友元函数的函数原型,友元函数的说明可以出现在类的任何地方,包括在private和public部分;
2)注意友元函数不是类的成员函数,所以友元函数的实现和普通函数一样,在实现时不用"::"指示属于哪个类,只有成员函数才使用"::"作用域符号;
3)友元函数不能直接访问类的成员,只能访问对象成员,
4)友元函数可以访问对象的私有成员,但普通函数不行;
5)调用友元函数时,在实际参数中需要指出要访问的对象,
什么是类的“成员函数”和“非成员函数”?
类有成员变量和成员函数。而函数中，不是任何一个类的成员的函数，就是非成员函数。例如：
class A{
public:
void f1(){}; // 这个就是成员函数。
void f2(); // 这个也是成员函数声明，其实现在类的外部。
};
void A::f2(){} // 这个是成员函数的实现。
void f3(){}; // 这个就是非成员函数，它不属于A，也不属于任何一起其他的类。
内联函数和成员函数的区别是什么？
成员函数是属于对象的, 静态函数才是属于类的. 如果在类体内定义的函数,则会被编译器默认为内联函数, 如果把函数的定义放在外面,且在函数的声明的时候加上关键字inline,则函数变为内联函数,否则为成员函数.
C++ 结构体的成员函数是什么？
C++允许在结构中定义函数，该函数称为成员函数。其描述形式如下：
struct 结构名{
数据成员
成员函数
}
下面是一个使用成员函数的例子
#include
/* run this program using the console pauser or add your own getch, system("pause") or input loop */
using namespace std;
struct Point
{
double m,n;
void Setab(double a,double b)
{
m=a;
n=b;
}
void display()
{
cout>" <<m<<"\t"<<n<<endl;
}
};
int main(int argc, char** argv)
{
Point p;
p.Setab(2,3);
p.display();
cout <<"数据成员"<<p.m<<"\t" <<p.n <<endl;
return 0;
}
总结:
1、用到了结构块 结构块中的函数调用的方法，写完上面程序发现C++的结构块像Java中静态方法，直接用结构名调用数据成员和成员函数;还有一个就是“\t” 是制表符意思是横向跳到下一个制表符的位置,相当于键盘上的Tab键，“\n”换行相当于endl;
2、在结构中成员默认都是public如不不希望对象直接访问数据成员，可以将数据成员使用private来修饰，即私有的数据成员，必须通过共有的成员函数才能使用，成为数据的封装性,下个小例子看看数据的封装性。
类的成员函数是什么？作用？
类的成员函数就是类里面定义的一个函数，作用就是说明类的一些操作
C++中的成员函数是什么意思啊？
把类能完成的功能写成一个函数，放在类的定义当中，这样的函数就是成员函数。
什么是类的成员函数和非成员函数
类的成员函数：
类的成员函数描述的是类的行为，是程序算法的实现部分，是对封装的数据进行操作的方法。类的成员函数的原型要写在类体中，原型说明了函数的参数表和返回值类型。而函数的定义一般在类外面，也可以直接在类内部定义。前者与普通函数不同的是，实现成员函数时要指明类的名称，具体形式为：
返回值类型 类名 ：：函数成员名（参数表）{函数体}；
而后者一般为一些短小的函数（5行以内），也就是内联函数。
请教下C++的普通函数与类的成员函数区别？
1、普通函数指的是C语言的函数，就是不写到class里的函数，这个通常是因为有一些库本身是C语言写的，C++包含C，所以可以用这些函数。
2、C++类里写的函数都是成员函数，但包括静态和非静态（也就是普通的）成员函数，静态的是C++类自己的，用类名加点来访问，普通的是属于对象的，用对象或指针来访问。
3、成员函数和成员变量是同一个层次的，都是为对象服务的，所以在成员函数里是可以访问成员变量的，所以你在函数里操作后，类的成员变量就发生变化了。
C++ 什么情况下，一个类中的成员函数不能调用这个类的另一个成员函数？
通常情况下有：
①funa是类中的静态成员函数，funb是类中的非静态成员函数
②funa是类中的常成员函数，funb是类中的非常成员函数
③funb是类中（该类为基类）的纯虚函数
等等
C++的成员函数和普通函数
首先要知道类存在的理由，为何要面向对象。
C中的结构体就是定义一种数据格式，可以存储若干数据元素，并且它们的内存是连续的。
结构体的作用是封装一组有关联的属性，它们共同维护某种概念实体的状态。
在早期经典纯C工程当中，有经验的开发者早就开始利用结构体与函数指针实现简单的面向对象。
但是用结构体+函数指针使用不方便不灵活，所以C++最大的使命，面向对象就诞生了。
要注意的是C++与C的区别除了类之外，还有函数多态的特性、命名空间、STL等等特性。
如果LZ学习过设计模式，那么这个问题就颇为清晰，类的存在是为了更灵活地描述某种概念实体以及对它的操作。
一个只有函数而没有属性的类，其描述的实体可以认为是一种抽象的动作实体。
用通俗的话来讲，一个继承Animal的Cat类描述一个猫，猫有属性（形态，叫声，年龄等），也有动作（吃喝拉撒睡），这就是最经典LZ也熟知的一种类。
而抽象的动作类，就有比如一个继承File的DiskFile或者FtpFile等，它主要描述的是一组动作（读与写），它也许有状态（属性），也许没有。
这种抽象的动作类为何而存在？经典的策略设计模式就会大量地使用这种写法。
比如你要做视频处理软件，视频需要解码与加码如果只是用纯函数的化你的代码就会如下丑陋：
if(0 == strcmp(fileType, AVI)) {
decode_AVI(file);
} else if(0 == strcmp(fileType, MP4)) {
decode_MP4(file);
}
.....
if(0 == strcmp(fileType, AVI)) {
encode_AVI(file);
} else if(0 == strcmp(fileType, MP4)) {
encode_MP4(file);
}
有一个类AVType，只有两个函数：encode、decode，然后有AVIType、MP4Type继承它，那么你的代码大致就是：
1
2
3
4
AVType* type = new AVIType(); // or MP4Type
type->decode(file);
....
type->encode(file);
当你的同类方法多起来（如rmvb、wmv、flv解码器等等）.
请问C++中成员函数在类里面定义和在类外定义有什么区别？
性能来说没啥区别。
不过放在类外，代码的定义和实现分开，有利于代码封转，别人需要调用你的接口的时候，你可以只给他头文件，代码的实现自己留着。
C++类的成员函数前加&什么意思
这个和函数参数加地址符的作用是一样的，用于返值返回的是引用而不是赋值。
也就是说，该函数返值会通过地址传送的方式给到函数调用者要求的返回值，这样可以节省对象赋值造成的内存浪费，通常用于返值是大型对象（而不是简单变量类型）的时候。
比如你有个class T,而这个函数的返值是return T; 加上地址符返值后，返回T变量的地址，将地址传递给接收返值的变量，而不是新建一个类T，调用类的复制函数创建一个新类。
在C++里，请问什么是类的数据成员？什么是类的成员函数？最好能举个例子，谢谢！
类的数据成员:就是类中的一个实例变量
类的成员函数:就i是类中的一个实例函数
class demo{
public :
void print();//类的成员函数
int age;//类的数据成员
};
希望对你有用...
求教c++大神，怎么在类里添加一个成员函数？
不用这玩意儿，直接在头文件里手动添加
error C2039: 'GetDibImage' : is not a member of 'CTestDoc'
提示GetDibImage不是CTestDoc的类成员函数
GetDibImage添加到这个类中
电脑中“函数”指的是什么
???
一段计算机程序代码，函数的出现主要是解决了程序代码共享问题，最初的计算机程序是顺序执行的，如果在一个程序工多个程序中需要实现同一种计算，这时实现同样计算的代码就会出现多次，而使用函数则不同，把该种计算封装在函数中，在需要使用的地方调用该函数即可，常见的DLL动态链接库，就是将若干函数封装起来，并且为调用者（宿主程序）提供服务，以实现代码共享！
什么是计算机函数？
了解代数中变量与函数的关系，就可以更好的了解函数，而计算机函数，和代数中函数意思异曲同工，所以了解代数函数，可以更好的帮你理解计算机函数。
计算机中的数据是指什么
十六进制：计算机中数据的一种表示方法
c++成员函数的定义
类（class）和对象（object）用于实现计算机世界中的“封装”（Encapsulation），即把数据（属性）和函数（操作）合成一个整体，这是面向对象程序设计最基本的特性。 C++类的定义
1、在C++中，“类”是一种数据类型。例如，商场中的商品可以用“商品类”来描述。 商品可以这样描述：
商品名称（用字符串描述）
该商品数量（用整型数描述）
该商品单价（用浮点数描述）
该商品总价（用浮点数描述）
相应的商品类如下：
class CGoods
{
public :
char Name[21] ; //对于中文可用wchar_t name[11]
int Amount ;
float Price ;
float Total_value ;
}; //最后的分号不可少
说明：关键字class是数据类型说明符，指出下面说明的是类。标识符CGoods是商品这个类的类型名。花括号中是构成类体的一系列的成员，此处为数据成员；关键字public是一种访问限定符，表示其后所列为公共成员，就是说可以在外部对这些成员进行访问。 2、类定义的更关键部分是对数据成员的操作。这可以用函数来完成。这些函数也作为类的成员存在！
class CGoods
{
private :
char Name[21] ;
int Amount ;
float Price ;
float Total_value ;
public :
void RegisterGoods(char*,int,float); //登记新商品，此处是函数头
void CountTotal(void) ; //计算商品总价值
void GetName(char*) ; //读取商品名
int GetAmount(void) ; //读取商品数量
float GetPrice(void) ; //读取商品单价
float GetTotal_value(void) ; //读取商品总价值
};
说明：这个描述商品的方案中，在类中引进了成员函数（或称函数成员）(member function),也就是函数也成了数据(类)中的成员。成员函数可以直接使用类定义中的任一成员，可以处理数据成员，也可调用其他函数成员。
类把数据（事物的属性）和函数（事物的行为——操作）封装为一个整体。
C++成员函数的定义
在前面，只对成员函数作了一个声明，或者讲只给出了函数的原型，并没有对函数进行定义。函数定义通常在类的说明之后进行。
商品类CGoods中的成员函数可以如下定义：（在前面的代码后加上以下部分）
void CGoods::RegisterGoods(char* name,int amount, float price)
//登记新商品
{
//char*是指向字符的指针类型说明，name现可理解为字符串
strcpy(Name , name) ; //字符串拷贝函数
Amount=amount ; Price=price ;
}
void CGoods::CountTotal(void) //计算商品总价值
{
Total_value = Price*Amount; }
void CGoods::GetName(char* name) //读取商品名
{
strcpy(name , Name);
}
int CGoods::GetAmount(void) //读取商品数量
{
return(Amount) ;
}
float CGoods::GetPrice(void) //读取商品单价
{
return(Price) ;
}
float CGoods::GetTotal_value(void) //读取商品总价值
{
return(Total_value) ;
}
类的成员函数怎样在类外定义，格式是什么
所谓对象就是客观事物在计算机中的抽象描述；类是对具有相似属性和行为的一组对象的统一描述。 3.1.1 类的定义 C++的类是在结构体的基础上扩充而来的。类是把各种不同类型的数据（称为数据成员）和对数据的操作（成员函数）组织在一起而形成的用户自定义的数据类型。 C++中，类定义包括类说明和类实现两大部分。 说明部分提供了对该类所有数据成员和成员函数的描述，而实现部分提供了所有成员函数的实现代码。 类定义的一般形式为： class 类名 {private: 数据成员或成员函数 protected: 数据成员或成员函数 public: 数据成员或成员函数 }; 说明： class是定义类的关键字，类名由用户自己定名，必须是C++的有效标识符，但一般首字母大写。 2. 大括号的部分是类的成员（数据成员和函数成员），它们分成三部分，分别由private、public、proctected三个关键字后跟冒号来指定。这三部分可以任何顺序出现，且在一个类的定义中，这三部分并非必须同时出现。（1）如果数据成员或成员函数在类的private部分，那么在类之外是不能存取的，只有类中的成员函数才能存取private的数据成员和成员函数。（2）在一个类的public部分说明的数据成员或成员函数可被程序中的任何函数或语句存取，public成员多为成员函数，用来提供一个与外界的接口，外界只有通过这个接口才可以实现对private成员的存取。 （3）在类的protected部分说明的数据成员和成员函数是不能在类之外存取的，只有类的成员函数及其子类（派生类）可以存取protected的成员。
初学c++，类中的成员函数和普通函数的区别是什么
面向对象的世界里没有普通函数的概念，普通函数是C++从面向过程的C语言里边拿过来的东西，面向对象的思想中不建议普通函数的存在。
c++中的常函数与普通函数有什么区别
常成员函数含义是函数体的代码不能修改实参的是，但是可以修改形参的值
1.常成员函数不能更新对象的数据成员 ；
2.不能调用该类中没有const修饰的成员函数 。
比如一个模板类
template
class array
{
public:
array(int sz = 50);
....
int listsize() const;
private:
t *alist;
int size;
};
c++中类的成员函数和函数成员有什么区别
一个意思，一般的说法是成员函数，但数据的说法是数据成员
C++虚函数与普通成员函数究竟有什么本质上的区别？
这个区别很重要在抽象的继承模型中叫做多态就是说，你定义一个类，他们具有相同的接口但是具体的不同的类又有不同的特征，实现之类可能也完全不同但是你可以用共同的基类指针来管理虚函数在实现的时候，其实是在类里建了一个隐含的成员变量，是一个指向函数的指针所以从基类调用也可以调用到继承类定义的成员函数。 例子: #include "stdafx.h"#include using namespace std; class A{public: virtual void test() { couttest();//虚函数，动态绑定，调用动态类型（实际对象类型）B版本 a->foo();//非虚函数，调用静态类型（指针类型）A的版本 B* b = new B; b->test();//虚函数，动态绑定，调用动态类型B版本 b->foo();//非虚函数，调用静态类型（指针类型）A的版本 b->A::foo();//这两个指定是调用A类版本 b->A::test(); return 0;}
C++已经声明或定义成员函数
void teach();a后面有一个多余的a。
另外所有定义要么在声明的时候就加上，要么全部挪到类外去。否则编译器会认为定义和声明是一个函数的两个重载版本而报错。
c++中，在定义类时，在类中的成员函数的表示方式是，类名：：成员函数，这是什么意思
::这个叫做作用域限定符，类名::函数名，是说明这个函数是这个类的成员函数，而不是其他类的。因为很多时候不同类都有同名的成员函数。
什么是C++中的成员变量和成员函数
定义了一个类，在这个类里面定义得函数就叫成员函数，定义的变量就叫成员变量。
在c++中静态成员函数也是类的成员函数，但是它的定义可在类的里面定义吗？
1.静态成员函数可以在类中被定义
2.普通类成员函数与静态成员函数的区别在于普通成员函数有一个隐藏的调用参数（this）指针，也就是说，静态成员函数不属于任何对象，它只属于类，在内存中只有一份。
学习函数有什么用
为了中考，高考。为了以后找工作，为了谋生，其他都是瞎扯，现在有多少人会研究学语数英有什么用的，学就完了。
怎样学习函数?
学习要立足课本，加强训练。这方面我在学习的时候深刻感到它的重要性，见的题型多了，解决起来就更容易。函数，说真的，刚学起来的却觉得很有难度，后来学的什么椭圆之类的曲线方程有不好学，这个我建议你联系图形，画图理解。要深知函数的三要素，定义域值域表达式，在知道这个的基础上然后按题型拓展，在这里首先要把书本知识了解了，然后就要涉及课外题目了，看典型的题目和专题，比喻说，有关于对称的，就要花时间去看。其实数学不难，就是要花时间去学，我高中是数学一直在班级领先，在这我强烈推荐要做题目，你就是了解了但数学现在是考试，要做题目，而且你也应该知道，书上的例题有限，所以这就要你课外训练。上课跟着老师走，基本能把书本学会，课后及时处理作业，不要拖。形成一个好习惯，这样就能及时掌握知识。好好学，其实数学并不难。
如果这样还不行的话，我知道一个博客挺好的，博主曾经从最后一名成为中考状元，只用了6个月的时间，后来他又经过3年的努力，成功的成为了一个高考状元，他的一些方法，也许对你会有所帮助！你可以百度找一下李晓鹏新浪博客，里面除了有函数的学习方法、重点归纳，还有各个科目详细的复习计划、解题窍门以及复习资料，都是他的经验总结，希望能够帮到你哦！博主的经历说明了一个道理，没有笨孩子，只有笨方法，只要你努力了，找对好方法，我相信你一定能够学好函数的！加油哦！O(∩_∩)O~
怎么学习excel函数公式?
学习EXCEL函数和公式的用法，可以从以下几方面着手：
1、理解函数和公式的基本概念。函数是EXCEL程序预先内置、能够以特定方法处理数据的功能模块，每个函数有其特定的语法结构和参数内容。公式则是使用者自己输入的包含函数和其他运算符且能进行特定数据运算的符号组合，要以符号“=”开始。EXCEL函数本身就是一种特殊的公式。
2、通过SUM、LEN、MOD、AND等几个比较简单的函数，掌握好公式和函数的输入方法、函数语法结构的概念、函数参数的概念、什么是常量、什么是逻辑值、什么是错误值、什么是单元格引用等重要概念。
3、单元格引用是函数参数的重要内容，分为相对引用、绝对引用和混合引用三个类型。灵活正确地使用单元格引用的类型，可以减少函数和公式输入的工作量，同时也能让计算的数据更精确有效。这需要在实践中认真摸索。
4、EXCEL内置的函数很多，有些函数是特定专业领域的，在实际工作使用中并非都能用到，因此不用把每个函数的语法结构和参数内容都进行掌握。但上述的有关函数和公式的基本概念必须要深刻理解、认真掌握，这些是学习函数和公式的核心关键。
5、在实际运用中，往往需要在一个公式里面嵌套多个函数，即将一个函数的计算结果作为另外一个函数的参数来使用。在使用嵌套函数的时候，必须要有清晰的参数概念，特别是多重嵌套时，一定要分清哪个函数是哪一个层次的参数。
6、多实践、多思考、多理解，结合自身的工作实际，对一些非常常用的重要函数要下死功夫，记住其语法结构和参数内容，做到能灵活运用、熟练输入。
初中什么时候学习函数
首先，
你是那个地区的的？
不过，我可以给你提供宜昌数学的有关信息。
初一-----初二：一次函数 ，正比例函数
初三上：反比例函数
初三下：二次函数（相当难）
不过这是教科书上的安排，老师可能会提前赶课程
高中阶段学习过哪些函数????
基本初等函数：
常函数、指数函数、幂函数（y=x,y=1/x,y=x^2,y=x^(1/2),y=x^3）、对数函数、三角函数
初等函数
比如：二次函数y=ax^2+bx+c(a≠0)，y=e^(2x+3)，y=x+1/x，y=sin(3x+2)等等。
