长春网站推广优化公司,app开发公司有哪些部门,短网址生成设计,曲阜做网站文章目录目录类与对象1.类成员函数2.类访问修饰符3.构造函数与析构函数4.拷贝构造函数5. 友元函数6.内联函数7.this指针8.指向类的指针9.类的静态成员目录
类与对象 #include iostreamusing namespace std;class Box
{public:double length; // 长度double breadth;…
文章目录目录类与对象1.类成员函数2.类访问修饰符3.构造函数与析构函数4.拷贝构造函数5. 友元函数6.内联函数7.this指针8.指向类的指针9.类的静态成员目录
类与对象 #include iostreamusing namespace std;class Box
{public:double length; // 长度double breadth; // 宽度double height; // 高度
};int main( )
{Box Box1; // 声明 Box1类型为 BoxBox Box2; // 声明 Box2类型为 Boxdouble volume 0.0; // 用于存储体积// box 1 详述Box1.height 5.0; Box1.length 6.0; Box1.breadth 7.0;// box 2 详述Box2.height 10.0;Box2.length 12.0;Box2.breadth 13.0;// box 1 的体积volume Box1.height * Box1.length * Box1.breadth;cout Box1 的体积 volume endl;// box 2 的体积volume Box2.height * Box2.length * Box2.breadth;cout Box2 的体积 volume endl;return 0;
}
当上面的代码被编译和执行时它会产生下列结果 Box1 的体积210 Box2 的体积1560
需要注意的是私有的成员和受保护的成员不能使用直接成员访问运算符 (.) 来直接访问. 1.类成员函数 #include iostream
#include limitsusing namespace std;class Box{
public://成员变量的定义 double length;double breadth;double height;//成员函数的定义double getVolume(void);void setLength(double len);void setBreadth(double bre);void setHeight(double hei);
};double Box::getVolume(void){return length*breadth*height;
}
void Box::setLength(double len){length len;
}
void Box::setBreadth(double bre){breadth bre;
}
void Box::setHeight(double hei){height hei;
}int main(){Box Box1; // 声明 Box1类型为 BoxBox Box2; // 声明 Box2类型为 Boxdouble volume 0.0; // 用于存储体积// box 1 详述Box1.setLength(6.0); Box1.setBreadth(7.0); Box1.setHeight(5.0);// box 2 详述Box2.setLength(12.0); Box2.setBreadth(13.0); Box2.setHeight(10.0);// box 1 的体积volume Box1.getVolume();cout Box1 的体积 volume endl;// box 2 的体积volume Box2.getVolume();cout Box2 的体积 volume endl;return 0;}当上面的代码被编译和执行时它会产生下列结果 Box1 的体积 210 Box2 的体积 1560
2.类访问修饰符 公有成员Public 公有成员在程序中类的外部是可访问的。您可以不使用任何成员函数来设置和获取公有变量的值如下所示
#include iostreamusing namespace std;class Line
{public:double length;void setLength( double len );double getLength( void );
};// 成员函数定义
double Line::getLength(void)
{return length ;
}void Line::setLength( double len )
{length len;
}// 程序的主函数
int main( )
{Line line;// 设置长度line.setLength(6.0); cout Length of line : line.getLength() endl;// 不使用成员函数设置长度line.length 10.0; // OK: 因为 length 是公有的cout Length of line : line.length endl;return 0;
}
当上面的代码被编译和执行时它会产生下列结果 Length of line : 6 Length of line : 10
私有成员Private 私有成员变量或函数在类的外部是不可访问的甚至是不可查看的。只有类和友元函数可以访问私有成员。 默认情况下类的所有成员都是私有的。例如在下面的类中width 是一个私有成员这意味着如果您没有使用任何访问修饰符类的成员将被假定为私有成员 class Box
{double width;public:double length;void setWidth( double wid );double getWidth( void );
};实际操作中我们一般会在私有区域定义数据在公有区域定义相关的函数以便在类的外部也可以调用这些函数如下所示
#include iostreamusing namespace std;class Box
{public:double length;void setWidth( double wid );double getWidth( void );private:double width;
};// 成员函数定义
double Box::getWidth(void)
{return width ;
}void Box::setWidth( double wid )
{width wid;
}// 程序的主函数
int main( )
{Box box;// 不使用成员函数设置长度box.length 10.0; // OK: 因为 length 是公有的cout Length of box : box.length endl;// 不使用成员函数设置宽度// box.width 10.0; // Error: 因为 width 是私有的box.setWidth(10.0); // 使用成员函数设置宽度cout Width of box : box.getWidth() endl;return 0;
}当上面的代码被编译和执行时它会产生下列结果 Length of box : 10 Width of box : 10
保护成员Protected 保护成员变量或函数与私有成员十分相似但有一点不同保护成员在派生类即子类中是可访问的。 在下一个章节中您将学习到派生类和继承的知识。现在您可以看到下面的实例中我们从父类 Box 派生了一个子类 smallBox。 下面的实例与前面的实例类似在这里 width 成员可被派生类 smallBox 的任何成员函数访问。
#include iostream
using namespace std;class Box
{protected:double width;
};class SmallBox:Box // SmallBox 是派生类
{public:void setSmallWidth( double wid );double getSmallWidth( void );
};// 子类的成员函数
double SmallBox::getSmallWidth(void)
{return width ;
}void SmallBox::setSmallWidth( double wid )
{width wid;
}// 程序的主函数
int main( )
{SmallBox box;// 使用成员函数设置宽度box.setSmallWidth(5.0);cout Width of box : box.getSmallWidth() endl;return 0;
} #includeiostream
#includeassert.h
using namespace std;class A{
public:int a;A(){a1 1;a2 2;a3 3;a 4;}void fun(){cout a endl; //正确cout a1 endl; //正确cout a2 endl; //正确cout a3 endl; //正确}
public:int a1;
protected:int a2;
private:int a3;
};
class B : public A{
public:int a;B(int i){A();a i;}void fun(){cout a endl; //正确public成员cout a1 endl; //正确基类的public成员在派生类中仍是public成员。cout a2 endl; //正确基类的protected成员在派生类中仍是protected可以被派生类访问。cout a3 endl; //错误基类的private成员不能被派生类访问。}
};
int main(){B b(10);cout b.a endl;cout b.a1 endl; //正确cout b.a2 endl; //错误类外不能访问protected成员cout b.a3 endl; //错误类外不能访问private成员system(pause);return 0;
}
10 1 sh: 1: pause: not found
protected 继承
#includeiostream
#includeassert.h
using namespace std;
class A{
public:int a;A(){a1 1;a2 2;a3 3;a 4;}void fun(){cout a endl; //正确cout a1 endl; //正确cout a2 endl; //正确cout a3 endl; //正确}
public:int a1;
protected:int a2;
private:int a3;
};
class B : protected A{
public:int a;B(int i){A();a i;}void fun(){cout a endl; //正确public成员。cout a1 endl; //正确基类的public成员在派生类中变成了protected可以被派生类访问。cout a2 endl; //正确基类的protected成员在派生类中还是protected可以被派生类访问。cout a3 endl; //错误基类的private成员不能被派生类访问。}
};
int main(){B b(10);cout b.a endl; //正确。public成员cout b.a1 endl; //错误protected成员不能在类外访问。cout b.a2 endl; //错误protected成员不能在类外访问。cout b.a3 endl; //错误private成员不能在类外访问。system(pause);return 0;
}private 继承
#includeiostream
#includeassert.h
using namespace std;
class A{
public:int a;A(){a1 1;a2 2;a3 3;a 4;}void fun(){cout a endl; //正确cout a1 endl; //正确cout a2 endl; //正确cout a3 endl; //正确}
public:int a1;
protected:int a2;
private:int a3;
};
class B : private A{
public:int a;B(int i){A();a i;}void fun(){cout a endl; //正确public成员。cout a1 endl; //正确基类public成员,在派生类中变成了private,可以被派生类访问。cout a2 endl; //正确基类的protected成员在派生类中变成了private,可以被派生类访问。cout a3 endl; //错误基类的private成员不能被派生类访问。}
};
int main(){B b(10);cout b.a endl; //正确。public成员cout b.a1 endl; //错误private成员不能在类外访问。cout b.a2 endl; //错误, private成员不能在类外访问。cout b.a3 endl; //错误private成员不能在类外访问。system(pause);return 0;
}
3.构造函数与析构函数 #include iostreamusing namespace std;class Line
{public:void setLength( double len );double getLength( void );Line(); // 这是构造函数private:double length;
};// 成员函数定义包括构造函数
Line::Line(void)
{cout Object is being created endl;
}void Line::setLength( double len )
{length len;
}double Line::getLength( void )
{return length;
}
// 程序的主函数
int main( )
{Line line;// 设置长度line.setLength(6.0); cout Length of line : line.getLength() endl;return 0;
}当上面的代码被编译和执行时它会产生下列结果 Object is being created Length of line : 6
带参数的构造函数 默认的构造函数没有任何参数但如果需要构造函数也可以带有参数。这样在创建对象时就会给对象赋初始值如下面的例子所示
#include iostreamusing namespace std;class Line
{public:void setLength( double len );double getLength( void );Line(double len); // 这是构造函数private:double length;
};// 成员函数定义包括构造函数
Line::Line( double len)
{cout Object is being created, length len endl;length len;
}void Line::setLength( double len )
{length len;
}double Line::getLength( void )
{return length;
}
// 程序的主函数
int main( )
{Line line(10.0);// 获取默认设置的长度cout Length of line : line.getLength() endl;// 再次设置长度line.setLength(6.0); cout Length of line : line.getLength() endl;return 0;
}
当上面的代码被编译和执行时它会产生下列结果 Object is being created, length 10 Length of line : 10 Length of line : 6 类的析构函数 类的析构函数是类的一种特殊的成员函数它会在每次删除所创建的对象时执行。 析构函数的名称与类的名称是完全相同的只是在前面加了个波浪号~作为前缀它不会返回任何值也不能带有任何参数。析构函数有助于在跳出程序比如关闭文件、释放内存等前释放资源。 下面的实例有助于更好地理解析构函数的概念
#include iostreamusing namespace std;class Line
{public:void setLength( double len );double getLength( void );Line(); // 这是构造函数声明~Line(); // 这是析构函数声明private:double length;
};// 成员函数定义包括构造函数
Line::Line(void)
{cout Object is being created endl;
}
Line::~Line(void)
{cout Object is being deleted endl;
}void Line::setLength( double len )
{length len;
}double Line::getLength( void )
{return length;
}
// 程序的主函数
int main( )
{Line line;// 设置长度line.setLength(6.0); cout Length of line : line.getLength() endl;return 0;
}
当上面的代码被编译和执行时它会产生下列结果 Object is being created Length of line : 6 Object is being deleted
4.拷贝构造函数 #include iostreamusing namespace std;class Line
{public:int getLength( void );Line( int len ); // 简单的构造函数Line( const Line obj); // 拷贝构造函数~Line(); // 析构函数private:int *ptr;
};// 成员函数定义包括构造函数
Line::Line(int len)
{cout 调用构造函数 endl;// 为指针分配内存ptr new int;*ptr len;
}Line::Line(const Line obj)
{cout 调用拷贝构造函数并为指针 ptr 分配内存 endl;ptr new int;*ptr *obj.ptr; // 拷贝值
}Line::~Line(void)
{cout 释放内存 endl;delete ptr;
}
int Line::getLength( void )
{return *ptr;
}void display(Line obj)
{cout line 大小 : obj.getLength() endl;
}// 程序的主函数
int main( )
{Line line(10);display(line);return 0;
}
当上面的代码被编译和执行时它会产生下列结果 调用构造函数 调用拷贝构造函数并为指针 ptr 分配内存 line 大小 : 10 释放内存 释放内存
下面的实例对上面的实例稍作修改通过使用已有的同类型的对象来初始化新创建的对象
#include iostreamusing namespace std;class Line
{public:int getLength( void );Line( int len ); // 简单的构造函数Line( const Line obj); // 拷贝构造函数~Line(); // 析构函数private:int *ptr;
};// 成员函数定义包括构造函数
Line::Line(int len)
{cout 调用构造函数 endl;// 为指针分配内存ptr new int;*ptr len;
}Line::Line(const Line obj)
{cout 调用拷贝构造函数并为指针 ptr 分配内存 endl;ptr new int;*ptr *obj.ptr; // 拷贝值
}Line::~Line(void)
{cout 释放内存 endl;delete ptr;
}
int Line::getLength( void )
{return *ptr;
}void display(Line obj)
{cout line 大小 : obj.getLength() endl;
}// 程序的主函数
int main( )
{Line line1(10);Line line2 line1; // 这里也调用了拷贝构造函数display(line1);display(line2);return 0;
}
当上面的代码被编译和执行时它会产生下列结果 调用构造函数 调用拷贝构造函数并为指针 ptr 分配内存 调用拷贝构造函数并为指针 ptr 分配内存 line 大小 : 10 释放内存 调用拷贝构造函数并为指针 ptr 分配内存 line 大小 : 10 释放内存 释放内存 释放内存 5. 友元函数 #include iostreamusing namespace std;class Box
{double width;
public:friend void printWidth( Box box );void setWidth( double wid );
};// 成员函数定义
void Box::setWidth( double wid )
{width wid;
}// 请注意printWidth() 不是任何类的成员函数
void printWidth( Box box )
{/* 因为 printWidth() 是 Box 的友元它可以直接访问该类的任何成员 */cout Width of box : box.width endl;
}// 程序的主函数
int main( )
{Box box;// 使用成员函数设置宽度box.setWidth(10.0);// 使用友元函数输出宽度printWidth( box );return 0;
}
当上面的代码被编译和执行时它会产生下列结果 Width of box : 10
6.内联函数 #include iostreamusing namespace std;inline int Max(int x, int y)
{return (x y)? x : y;
}// 程序的主函数
int main( )
{cout Max (20,10): Max(20,10) endl;cout Max (0,200): Max(0,200) endl;cout Max (100,1010): Max(100,1010) endl;return 0;
}当上面的代码被编译和执行时它会产生下列结果 Max (20,10): 20 Max (0,200): 200 Max (100,1010): 1010
7.this指针 #include iostreamusing namespace std;class Box
{public:// 构造函数定义Box(double l2.0, double b2.0, double h2.0){cout Constructor called. endl;length l;breadth b;height h;}double Volume(){return length * breadth * height;}int compare(Box box){return this-Volume() box.Volume();}private:double length; // Length of a boxdouble breadth; // Breadth of a boxdouble height; // Height of a box
};int main(void)
{Box Box1(3.3, 1.2, 1.5); // Declare box1Box Box2(8.5, 6.0, 2.0); // Declare box2if(Box1.compare(Box2)){cout Box2 is smaller than Box1 endl;}else{cout Box2 is equal to or larger than Box1 endl;}return 0;
}当上面的代码被编译和执行时它会产生下列结果 Constructor called. Constructor called. Box2 is equal to or larger than Box1
8.指向类的指针
一个指向 C 类的指针与指向结构的指针类似访问指向类的指针的成员需要使用成员访问运算符 -就像访问指向结构的指针一样。与所有的指针一样您必须在使用指针之前对指针进行初始化。 下面的实例有助于更好地理解指向类的指针的概念
#include iostreamusing namespace std;class Box
{public:// 构造函数定义Box(double l2.0, double b2.0, double h2.0){cout Constructor called. endl;length l;breadth b;height h;}double Volume(){return length * breadth * height;}private:double length; // Length of a boxdouble breadth; // Breadth of a boxdouble height; // Height of a box
};int main(void)
{Box Box1(3.3, 1.2, 1.5); // Declare box1Box Box2(8.5, 6.0, 2.0); // Declare box2Box *ptrBox Box1;; // Declare pointer to a class.// 保存第一个对象的地址// 现在尝试使用成员访问运算符来访问成员cout Volume of Box1: ptrBox-Volume() endl;// 保存第二个对象的地址ptrBox Box2;// 现在尝试使用成员访问运算符来访问成员cout Volume of Box2: ptrBox-Volume() endl;return 0;
}当上面的代码被编译和执行时它会产生下列结果 Constructor called. Constructor called. Volume of Box1: 5.94 Volume of Box2: 102
9.类的静态成员
我们可以使用 static 关键字来把类成员定义为静态的。当我们声明类的成员为静态时这意味着无论创建多少个类的对象静态成员都只有一个副本。 静态成员在类的所有对象中是共享的。如果不存在其他的初始化语句在创建第一个对象时所有的静态数据都会被初始化为零。我们不能把静态成员的初始化放置在类的定义中但是可以在类的外部通过使用范围解析运算符 :: 来重新声明静态变量从而对它进行初始化如下面的实例所示。 下面的实例有助于更好地理解静态成员数据的概念
#include iostreamusing namespace std;class Box
{public:static int objectCount;// 构造函数定义Box(double l2.0, double b2.0, double h2.0){cout Constructor called. endl;length l;breadth b;height h;// 每次创建对象时增加 1objectCount;}double Volume(){return length * breadth * height;}private:double length; // 长度double breadth; // 宽度double height; // 高度
};// 初始化类 Box 的静态成员
int Box::objectCount 0;int main(void)
{Box Box1(3.3, 1.2, 1.5); // 声明 box1Box Box2(8.5, 6.0, 2.0); // 声明 box2// 输出对象的总数cout Total objects: Box::objectCount endl;return 0;
}当上面的代码被编译和执行时它会产生下列结果 Constructor called. Constructor called. Total objects: 2 #include iostreamusing namespace std;class Box
{public:static int objectCount;// 构造函数定义Box(double l2.0, double b2.0, double h2.0){cout Constructor called. endl;length l;breadth b;height h;// 每次创建对象时增加 1objectCount;}double Volume(){return length * breadth * height;}static int getCount(){return objectCount;}private:double length; // 长度double breadth; // 宽度double height; // 高度
};// 初始化类 Box 的静态成员
int Box::objectCount 0;int main(void)
{// 在创建对象之前输出对象的总数cout Inital Stage Count: Box::getCount() endl;Box Box1(3.3, 1.2, 1.5); // 声明 box1Box Box2(8.5, 6.0, 2.0); // 声明 box2// 在创建对象之后输出对象的总数cout Final Stage Count: Box::getCount() endl;return 0;
}当上面的代码被编译和执行时它会产生下列结果 Inital Stage Count: 0 Constructor called. Constructor called. Final Stage Count: 2 静态成员变量在类中仅仅是声明没有定义所以要在类的外面定义实际上是给静态成员变量分配内存。如果不加定义就会报错初始化是赋一个初始值而定义是分配内存。
