C++_类与对象

最新推荐文章于 2024-07-31 21:09:59 发布
最新推荐文章于 2024-07-31 21:09:59 发布
阅读量1.3k 收藏 4
点赞数 2
分类专栏： 编程语言 文章标签： 类与对象
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gsh_hello_world/article/details/52856346
版权

概述

1.面向对象程序设计的基本特点：抽象、封装、继承、多态；

2.C++中类的概念，是进行面向对象程序设计的基础，在面向对象程序设计中占据着核心地位，它把数据和作用在这些数据上的操作组合在一起，是封装的基本单元；

3.对象是类的实例，类定义了属于该类的所有对象的共同属性。

类和对象的定义

<span style="font-size:18px;"><strong>1.类定义</strong></span>
class  类名                          //以class开头
{                                    //类的说明部分
   	      private：              //类的成员
                 私有数据成员和成员函数；
          protected：
                 保护数据成员和成员函数；
     	public：
                 公有数据成员和成员函数；
};
类定义的说明:
1.class是定义类的关键字；
<类名>用于唯一标识一个类；
一对大括号内是类的说明部分，说明该类的所有成员；
类的成员包括:数据成员和成员函数两部分；
类的成员从访问权限上分有以下三类：
公有的（public）
私有的（private）
保护的（protected
其中默认为private权限。
关键字public，private和protected被称为访问权限修饰符，它们在类体内与出现的先后顺序无关，并且允许多次出现，用它们来说明类成员的访问权限。

类的公有成员(public）
公有部分往往是一些操作，即成员函数，它提供给用户接口功能，使用户通过这些成员函数来调用私有数据，被说明为公有的成员可以被程序中的任何代码访问；

类的私有成员(private):
私有部分通常是一些数据成员。用户无法访问它们，只能被类本身的成员函数及友元类的成员函数和友元函数访问，其他类的成员函数，包括其派生类的成员函数都不能访问它们；private成员是被隐藏的部分。
类的保护成员( protected）:
与私有成员类似，只是除了类本身的成员函数和说明为友元类的成员函数可以访问保护成员外，该类的派生类的成员也可以访问。
2.例子
说明：为什么把类的定义和实现放在不同的文件之中：
（1）类的实现文件通常较大，将两者混在一起不便于阅读、管理和维护；
（2）对软件开发商来说，可以向用户提供一些程序模块，这些程序模块，往往只向用户公开类的定义，即接口，而不公开程序的源代码，类的定义与实现的分开管理可以很好地解决这问题,便于团队式的大型软件的开发；
（3）将类的成员函数的实现放在定义文件中与放在实现文件中，在编译时的含义是不一样的，若将类的成员函数的实现直接放在定义文件中，则类的成员函数将作为内置函数处理，显然将所有类的成员函数作为内联函数处理不合适
内置函数将该函数的代码插入在函数的每个调用处，作为函数体的内部扩展，用来避免函数调用机制所带来的开销。
虽然这种做法可以提高执行效率，但如果函数体过长会有不良后果，因此，一般对非常简单的函数，才声明成内置函数。
main.cpp 
#include "student.h"
int main()
{
	student s;//定义对象s
	s.input("12", "li ming", 98);
	s.display();
	s.ModifyScore(99);
	s.display();
	getchar();
	return 0;

}
student.cpp 
#include "student.h"
using namespace std;
#pragma warning(disable:4996)
void student::input(const char* id, const char* na, float s)
{
	score = s;
	Id = new char[strlen(id) + 1];//给变量分配存储空间
	strcpy(Id, id);//给变量Id赋值
	name = new char[strlen(id) + 1];//给变量分配存储空间
	strcpy(name, na);//给变量name赋值
}

void student::ModifyScore(float s)
{
	score = s;
}

void student::display()
{
	cout << "id:" << Id << endl;
	cout << "name:" << name << endl;
	cout << "score:" << score << endl;
}
student.h 
#ifndef STUDENT_H
#define STUDENT_H
#include <iostream>
#include <string.h>
#include <stdio.h>
class student//定义类
{
public://类的共有成员
	void input(const char* id, const char* na, float s);
	void ModifyScore(float s);
	void display();
private:
	float score;//学生成绩
	char* name;//学生姓名
	char* Id;//学生学号
};


#endif // STUDENT_H_INCLUDED
<span style="font-size:18px;">在定义类对象时，若我们定义的是指向此类对象的指针，则使用此类成员时，不再用“.’操作符，而是使用“->”操作符。</span>
<span style="font-size:18px;">例2：通过指针进行成员函数调用</span>
#include “student.h”
void main( )
{
student *s2,s;                          //定义类student的对象s2
s2=&s;
s2->input(“9902”,”Li”,90);    
s2-> display( );                    //调用公有成员函数display
s2-> modify(95);                 //调用公有成员函数
s2-> display( );
}

 
 3.对象的定义及使用 

 

 
   为了使用类，必须说明类的对象。在定义类时，系统是不会给类分配存储空间的，只有定义类对象时才会给对象分配相应的内存空间。 

 

 
 类是数据类型，对象是此类型说明的变量：point p1，p2；circle c1，c2程序运行时，通过为对象分配内存创建对象，同类的多个对象占据内存的不同区域，每个对象保存的数据不同，但是，用来操作数据的程序代码是一样的。 

 

 
 4.类的私有成员（private） 

 

 
 类私有成员的存取控制最为严格，只有类本身成员函数或其友元函数可以存取。例：  私有成员错误使用的例子 

 

 
  
 
#include <iostream.h>
#include <string.h>
class person
{
  public：
      int age;
      char name[10];
};

void main()
{
person liu;
liu.age=30;                         //错误，不访问或操作对象的私有成员
strcpy(liu.name,”jia”);                  //错误
cout<<liu.name<< “is”<<liu.age<<“year old.”<<endl; //错误

 
 5.类的公有成员（public） 
 
 
 类的公有成员数据可以被类成员函数和外部函数使用。 
 
 

 

 
 
#include <iostream.h>
#include <string.h>
class person
{
  publice：
      int age;
      char name[10];
};

void main()
{
person liu;
liu.age=30;                         //正确
strcpy(liu.name,”jia”);                  
cout<<liu.name<< “is”<<liu.age<<“year old.”<<endl;
 
 注意：把类的私有成员改为公有成员，显然破坏了类的数据封装，一般情况下用公有的
 成员函数来访问私有成员数据。 

 

 
 
  

 

 
 
构造函数和析构函数
 
 
 
  1.概述 
 
 
 
 
  构造函数的功能是对对象的初始化,主要是对数据成员初始化,并分配存储空间，注意:应声明为public 类型，因对象创建时，系统自动调用，是通过对象来使用，任何成员只要通过对象使用就属于类外使用；析构函数主要功能是对类中动态分配的内存进行释放,它在对象消失时自动调用。构造函数和析构函数都是类的成员函数。
  
 
 
 
 
  2.构造函数 
 
 
 
 
  （1）构造函数特征
 <1>构造函数的名字与类名相同；
 <2>构造函数没有返回值,在声明和定义时不能说明它的类型，甚至void；
 <3>构造函数的功能是对对象进行初始化,且一般只对数据成员初始化，一般不能作赋初值以外的事情；
 <4>不能像其他成员函数那样被显示调用，在对象创建时被自动调用；
 <5>在一个类中可以定义多个构造函数（重载）； 
 
 
 
 
  <6>如果一个类没有定义构造函数，编译器会自动生成一个不带参数的默认构造函数，其格式如下： 
 
 
 <类名>::<默认构造函数名>（）
 {
 } 

 

 
 （2）构造函数的形式有几种:
 带参数的构造函数
 缺省参数的构造函数
 重载构造函数
 拷贝构造函数 
 
 

 

 
 <1>一般形式的构造函数的应用 

 

 
 student.h 

 

 
  
 
#ifndef STUDENT_H
#define STUDENT_H
#include <iostream>
#include <string.h>
#include <stdio.h>
class student//定义类
{
public:	//类的共有成员
	student();		//构造函数声明
	~student();		//析构函数声明
	void chgName(char *pn);	//修改姓名
	void chgId(char *pid);	//修改学号
	void chgScore(float s);	//修改分数
	void display();	//显示信息
private://类的私有成员
	float score;	//学生成绩
	char *name;		//学生姓名
	char *Id;		//学生学号
};


#endif // STUDENT_H_INCLUDED

 
 
 
  
  
 
 stduent.cpp 
 
 
 
#include "student.h"
using namespace std;
#pragma warning(disable:4996)
student::student()//构造函数定义
{
	Id = new char[11];			//给变量分配存储空间
	strcpy(Id, "2016140282");	//给变量Id赋值
	name = new char[10];		//给变量分配存储空间
	strcpy(name, "高世皓");		//给变量name赋值
	score = 90;
}
student::~student()
{
	delete [] name;	//释放内存空间
	delete [] Id;	//释放内存空间
}
void student::chgName(char *pn)
{
	delete [] name;
	name = new char[strlen(pn) + 1];//给变量重新分配存储空间
	strcpy(name, pn);
}
void student::chgId(char *pid)
{
	delete [] Id;
	Id = new char[strlen(pid) + 1];//给变量重新分配存储空间
	strcpy(Id, pid);
}
void student::chgScore(float s)
{
	score = s;
}

void student::display()
{
	cout << "id:" << Id << endl;
	cout << "name:" << name << endl;
	cout << "score:" << score << endl;
}

 
 
 

 

 
 main.cpp 

 

 
  
 
#include "student.h"
int main()
{
	student s;		//定义对象s
	s.display();	//显示初始化值
	s.chgId("2016140283");
	s.chgName("zhangsan");
	s.chgScore(87);
	s.display();
	getchar();
	return 0;

}

 
 <2>带参数的构造函数 

 

 
 在创建对象时通过传递不同的参数，实现对不同对象进行不同的初始化。注意：构造函数的参数个数和类型规定了声明一个对象时，对这个对象进行初始化所需要的初始值的个数和类型。
  

 

 
  
 
#include<iostream>
using namespace std;
class point
{
public:
	point(int vx, int vy);//声明带参数的构造函数
	void offset(int ax, int ay);
	void display();//显示坐标
private:
	int x;
	int y;
};
int main()
{
	point p(10, 10);
	p.display();
	p.offset(10, 10);
	p.display();
	getchar();
	return 0;
}

point::point(int vx, int vy)
{
	x = vx;
	y = vy;
}

void point::offset(int ax, int ay)
{
	x = x + ax;
	y = y + ay;
}

void point::display()
{
	cout << "x = " << x << endl;
	cout << "y = " << y << endl;
}

 
 
 
  
  
 
 
 带参数构造函数的应用 

 

 
 student.h 

 

 
  
 
#ifndef STUDENT_H
#define STUDENT_H
#include <iostream>
#include <string.h>
#include <stdio.h>
class student//定义类
{
public:	//类的共有成员
	student();		//不带参数的构造函数声明
	student(char *pn, char *pid, float s);//带参数的构造函数声明
	~student();		//析构函数声明
	void chgName(char *pn);	//修改姓名
	void chgId(char *pid);	//修改学号
	void chgScore(float s);	//修改分数
	void display();	//显示信息
private://类的私有成员
	float score;	//学生成绩
	char *name;		//学生姓名
	char *Id;		//学生学号
};
#endif // STUDENT_H_INCLUDED

 
 
 

 

 
 student.cpp 

 

 
  
 
#include "student.h"
using namespace std;
#pragma warning(disable:4996)
student::student()//构造函数定义
{
	Id = new char[11];			//给变量分配存储空间
	strcpy(Id, "2016140282");	//给变量Id赋值
	name = new char[10];		//给变量分配存储空间
	strcpy(name, "高世皓");		//给变量name赋值
	score = 90;
}
student::student(char * pn, char * pid, float s)
{
	name = new char[strlen(pn) + 1];//分配存储空间
	strcpy(name, pn);
	Id = new char[strlen(pid) + 1];//分配存储空间
	strcpy(Id, pid);
	score = s;
}
student::~student()
{
	delete [] name;	//释放内存空间
	delete [] Id;	//释放内存空间
}
void student::chgName(char *pn)
{
	delete [] name;
	name = new char[strlen(pn) + 1];//给变量重新分配存储空间
	strcpy(name, pn);
}
void student::chgId(char *pid)
{
	delete [] Id;
	Id = new char[strlen(pid) + 1];//给变量重新分配存储空间
	strcpy(Id, pid);
}
void student::chgScore(float s)
{
	score = s;
}

void student::display()
{
	cout << "id:" << Id << endl;
	cout << "name:" << name << endl;
	cout << "score:" << score << endl;
}

 
 
 

 

 
 main.cpp 

 

 
  
 
#include "student.h"
int main()
{
	student s;		//定义对象s
	s.display();	//显示初始化值
	s.chgId("2016140283");
	s.chgName("张三");
	s.chgScore(87);
	s.display();
	
	student s1("李四", "2016140284", 89);
	s1.display();
	getchar();
	return 0;

}

 
 <3>缺省参数的构造函数 
 
 
 构造函数中的参数可以指定默认值，此时如果在创建对象时不指定参数，编译系统将使用默认值来初始化数据成员。 
 
 
 
#include <iostream>
using namespace std;

class point
{
private:
	int x;
	int y;
public:
	point(int vx = 0, int vy = 0)
	{
		x = vx;
		y = vy;
	}
	void display()
	{
		cout << "x = " << x << ",y = " << y << endl;
	}
};

int main()
{
	point p1;
	p1.display();
	point p2(10);
	p2.display();
	point p3(100, 100);
	p3.display();
	getchar();
}
运行结果： 

 

 
 
x = 0, y = 0 
x = 10, y = 0 
x =100, y = 100
 
 在函数所带的参数中,有一部分可以缺省,而一部分不可缺省,此时采取的规则是所有取缺省值的参数必须出现在不取缺省值的参数的右边，例: 
 
 
 
point(int x,int y=0);   //正确
point(int x=0,int y);   //错误
void f(int i,int j,int k=10);   //正确
void xyout (char *str, int  x=-1,int y=-1);   //正确
void f(int i,int j=10,int k);   //错误
 
  
 
 
  
  
 
 
 （3）构造函数的重载 

 

 
 构造函数可以像普通函数一样被重载，C++根据说明中的参数个数和类型选择合适的构造函数。若类 X 具有一个或多个构造函数，创建类 X 的对象时，C++会根据参数选择调用其中一个。构造函数可以使用默认参数，但谨防二义性。 
  
 
class {
            //…
   public：
       x();         //不带参数的构造函数                
       x(int);         //只带一个整形参数的构造函数
       x(int,char);     
       x(float,char);
         //…
}；
//上面声明的四个构造函数，虽然名字相同，但它们所带的参数个数和类型均有所差别，这样系统在调用时可以找到合适的构造函数，而不致造成二义性。
int main()
{
  x a;                //定义x类的对象,并同时调用构造函数
  x b(1);
  x c(1,’c’);
  x d(3.5,’d’);
//…
}

 
 （4）拷贝构造函数 
 
 
 <1>是特殊的构造函数，是用一个已存在的对象，来初始化一个同类的新对象；函数形参是对象的引用。 

 

 
 <2>格式：<类名> :: <拷贝初始化构造函数名> (const <类名> & <引用名>) 

 

 
 { 

 

 
 构造函数的函数体 

 

 
 } 

 

 
 <3>拷贝构造函数的两种定义形式： 

 

 
 系统产生：如果类中没有说明拷贝初始化构造函数，则编译系统自动生成一个具有上述形式的缺省拷贝初始化构造函数，作为该类的公有成员。系统具有为类产生一个缺省的拷贝构造函数的功能，我们只要使用即可，如下例。 

 

 
  
 
#include <iostream>
using namespace std;

class point
{
private:
	int x;
	int y;
public:
	point(int vx, int vy)
	{
		x = vx;
		y = vy;
	}
	void print()
	{
		cout << "x = " << x << ",y = " << y << endl;
	}
};
int main()
{
	point p1(10, 20);
	point p2(p1);//也可以p2 = p1
	//此时调用的是系统缺省的拷贝构造函数。拷贝构造函数将p1对象的各个域的值都拷贝给了p2对象相应的域；因此p2对象的数据成员的值与p1对象的相同。
	p1.print();
	p2.print();
	getchar();
}
 
 用户定义 

 

 
  
 
#include <iostream>
using namespace std;

class point
{
private:
	int x;
	int y;
public:
	point(int vx, int vy);//带参数的构造函数
	void print();//输出
	point(const point &p);//声明拷贝构造函数

};
point::point(int vx, int vy)
{
	x = vx;
	y = vy;
}
void point::print()
{
	cout << "x = " << x << ",y = " << y << endl;
}

point::point(const point & p)//定义拷贝构造函数
{
	this -> x = p.x + 10;
	this -> y = p.y + 10;
}

int main()
{
	point p1(10, 20);
	point p2(p1);
	p1.print();
	p2.print();
	getchar();
}
 
 
 
 注意： 

 

 

1>定义并用其他类对象初始化一个对象时，拷贝构造函数被调用，如上例；
 

2>若函数的形参为类对象，调用函数时，实参赋值给形参，系统自动调用拷贝构造函数，如例1；
 

 
3>当对象作为函数值返回时， 
拷贝构造函数被调用，如例2； 

 

 
4> 
含有指针成员的类，必须提供自己的拷贝构造函数和操作符函数。 

 

 
 5>例:下面情况不会调用拷贝构造函数 

 

 
  
 
mytest c1（2,“hello”);
mytest c2;
c2=c1;
 
 
</pre><span style="font-size:18px; color:#ff0000">例1：</span></div><div><span style="font-size:18px"></span><pre code_snippet_id="1945638" snippet_file_name="blog_20161108_25_6622616" name="code" class="cpp">#include <iostream>
using namespace std;
 class point
 {
 private:
	 int x;
	 int y;
 public:
	 point(int vx, int vy);//带参数的构造函数
	 void print();//输出
	 point(const point &p);//自定义拷贝构造函数
 };

void point::print()
{
	cout << "x = " << x << ",y = " << y << endl;
}
point::point(const point & p)
{
	x = p.x + 11;
	y = p.y + 22;

}
void fun(point p)
{
	cout << "调用fun函数" << endl;
	cout << "p:";
	p.print();
}
point::point(int vx, int vy)
{
	cout << "调用带参数的构造函数" << endl;
	x = vx;
	y = vy;
}
int main()
{
	point p1(1, 2);//调用带参数的构造函数
	fun(p1);//调用拷贝构造函数
	cout << "p1:";
	p1.print();
	getchar();
}
 
 
 运行结果： 

 

 
  
 
调用带参数的构造函数
调用fun函数
p:x= 12, y = 24
p1:x = 1, y = 2
 
 
 
 例2： 
 
 
 
 

 

 
  
 
#include <iostream>
using namespace std;
 class point
 {
 private:
	 int x;
	 int y;
 public:
	 point(int vx, int vy);//带参数的构造函数
	 void print();//输出
	 point(const point &p);//自定义拷贝构造函数
 };

void point::print()
{
	cout << "x = " << x << ",y = " << y << endl;
}
point::point(const point & p)
{
	x = p.x + 13;
	y = p.y + 25;

}
point fun()
{
	point p1(1, 2);//调用带参数的构造函数
	cout << "调用fun函数" << endl;
	return p1;
}
point::point(int vx, int vy)
{
	cout << "调用带参数的构造函数" << endl;
	x = vx;
	y = vy;
}
int main()
{
	point p2(2,2);
	p2 = fun();
	cout << "p2:";
	p2.print();
	getchar();
}
 
 
 
  
  
 
 
 
 
  运行结果： 
 
 
 
 
  
  
 
 
 
 
   
  
调用带参数的构造函数
调用带参数的构造函数
调用fun函数
p2:x = 14, y = 27
 
  
 
   
  
  
 
  3.析构函数 
 
 
 
 
  析构函数也是类的特殊成员函数，它的主要功能是对类中动态分配的内存进行释放，它在对象消失时自动调用； 
 
 
 
 
  析构函数的名称与其类名称相同，并在名称的前面加~；析构函数的函数体可写在类体内，也可以写在类体外； 
 
 
 

   析构函数没有参数和返回值；一个类中只可能定义一个析构函数，所以析构函数不能重载。 
  
 如果用到了动态内存,且变量不是数组,则析构函数的一般定义形式为: 
  
 
  
~ 类名 ( )
{
delete 变量名;
}
 
  
 如果变量是数组析构函数的一般形式为: 
  
 
  
~ 类名 ( )
{
delete [ ] 变量名;
}
 
  
 
  注意：用析构函数释放的空间是由构造函数分配，而不是由运算符new分配的。 
  
 
 
 
 
 
  
 
 
 
 例1：构造函数用于类型转换 
 
 
 
//利用构造函数，由系统自动进行类型转换。
#include <iostream>
using namespace std;
#pragma warning(disable:4996)  
class A
{
private:
	char name[20];
public:
	A(char n[])//带参数的构造函数
	{
		strcpy((char *)name, n);
		cout << "调用带参数的构造函数" << endl;
	}
	void print()
	{
		cout << "name = " << name << endl;
	}
};
void fun(A a)
{
	a.print();
}
int main()
{
	char a[20] = "shgao";
	fun(a);//自动利用A类的构造函数把a 转换成：A 类
	getchar();
}
/*
	运行结果：
	name = shgao
*/
 
 
 
  
 
 
 
 
对象数组
 
 数组也可以由对象组成，对象数组的每一个元素都是同类的对象； 

 

 
 在创建对象数组时，同样需要调用构造函数； 

 

 
 可以在定义数组的时候提供实参进行初始化； 

 

 
 如果定义对象数组student stud[3] = {100,98,96}; 编译系统职位每个对象元素的构造函数传递一个实参； 

 

 
 如果构造函数有多个参数， 在花括号中分别写出构造函数并指定实参。 

 

 
 
  

 

 
 例：对象数组的使用方法 

 

 
  
 
#include <iostream>
using namespace std;
class Box
{
private:
	int length;
	int width;
	int height;
public:
	int volume();
	Box(int l = 11, int w = 12, int h = 14):length(l),width(w),height(h){}
	void print();
};

int Box::volume()//计算体积
{
	int v;
	v = length * width * height;
	return v;
}

void Box::print()//打印体积
{
	cout << "volume:" << volume() << endl;
}

int main()
{
	Box box[3] = 
	{
		Box(21,34,53),//调用构造函数，提供实参
		Box(12,24,52),
		Box(21,33,51)
	};
	box[0].print();
	box[1].print();
	box[2].print();
	getchar();
}

<h1><span style="font-size:18px;">与对象相关的指针</span></h1>
 
 1.指向对象的指针 
 
 

 

 
 
 
  对象空间的起始地址就是对象的指针，可以定义一个指针变量，用来存放对象的指针。 
 
 

 

 
 
 
  Time *pt;//定义pt为指向Time类对象的指针变量 
 
 
 
 
  Time t1;//定义t1为Time类的对象 
 
 
 
 
  pt = &t1;//将t1的起始地址赋给pt 
 
 

 

2.指向对象数据成员的指针
 

 
 
数据类型名 *指针变量名    p1 = &t1.hour;//将对象t1的数据成员hour的地址赋给p1，p1指向t1.hour
 

 

 
 3.指向对象成员函数的指针 

 

 
 
 
  （1）数据类型名 (类名::*指针变量名) (参数);    void  (Time::*p2) ();//p2为指向Time类中公用成员函数的指针变量 
 
 
 
 
  （2）使指针变量指向一个公用成员函数的一般形式为：指针变量名 = &类名::成员函数名； 
 
 
 
 
  （3）指针变量的类型必须与上式中等号右侧的成员函数的类型相匹配：函数参数的类型和参数个数；函数返回      值；所属的类。 
 
 
 
 
   
  
#include <iostream>
using namespace std;
class Time
{
public:
	int hour;
	int minute;
	int second;
	Time(int h, int m,int s):hour(h), minute(m), second(s){}//带参数的构造函数
	void print_time();
};

void Time::print_time()//显示时间
{
	cout << hour << ":" << minute << ":" << second << endl;
}

int main()
{
	Time t1(11, 11, 12);//定义对象
	int *pt1 = &t1.hour;//定义指向对象的数据成员的指针
	cout << "hour:" << *pt1 << endl;
	t1.print_time();//显示时间
	Time *pt2;//定义指向对象的指针
	pt2 = &t1;//使其指向t1
	pt2->print_time();
	void (Time::*pt3)();//定义指向对象成员函数的指针
	pt3 = &Time::print_time;//使其指向print_time成员函数
	(t1.*pt3)();//调用对象t1中p3所指的成员函数
	getchar();
}
/*
运行结果：
hour:11
11:11:12
11:11:12
11:11:12
*/
 
  
 
   
 
  
 
  
 
   
 
  
 
  
//对类对象定义引用
#include <iostream>
using namespace std;
class Point
{
private:
	int x;
	int y;
public:
	Point(int vx, int vy):x(vx),y(vy){}//带参数的构造函数
	void offset(int vx, int vy)
	{
		x = x + vx;
		y = y + vy;
	}
	void print()
	{
		cout << "x = " << x << ",y = " << y << endl;
	}
};
int main()
{
	Point point(1, 1);//定义类对象
	Point &pt = point;//定义point的引用pt
	point.offset(1, 2);
	point.print();
	pt.offset(2, 3);
	pt.print();
	getchar();
}
/*
运行结果：
x = 2, y = 3
x = 4, y = 6

*/
 
  
 
  
 
 
 

 

this指针
 

 
 1.每个对象中的数据成员都分别占有存储空间，不同对象都调用同一个函数代码段。当不同对象的成员函数引用数据成员时，怎么能保证引用的是所指定的对象的数据成员呢？在每一个成员函数中都包含一个特殊的指针，这个指针称为this。它是指向本类对象的指针，它的值是当前被调用的成员函数所在的对象的起始地址。
  

 

2.this指针是隐式使用的，它是作为参数被传递给成员函数的。成员函数volume的定义如下： 
 int Box∷volume( )
 {return (height*width*length);      
 }
 C++把它处理为
 int Box∷volume(Box *this)
 {return(this->height * this->width * this->length);      
 }
 在调用该成员函数时，实际上是用以下方式调用的： 
 a.volume(&a);
 将对象a的地址传给形参this指针。然后按this的指向去引用其它成员。
 这些都是编译系统自动实现的，编程序者不必人为地在形参中增加this指针
 
 

 
 
 
 
 

 

 
 
 


                

        

        

    

  


    

      

        

            

              
                
                  大师兄电子工作室
                
              
            

            

                关注
              
            

        

        

          
      

      

            

                专栏目录
          









                



	

		

			

				
					
C++里面类和对象是什么意思？

				
			

			

				

					C语言C++学习俱乐部：765860056
				

				

					10-13
					
					1424
					
				

			

		

		

			
				
本文章向大家介绍C++类和对象到底是什么意思？，主要包括C++类和对象到底是什么意思？使用实例、应用技巧、基本知识点总结和需要注意事项，具有一定的参考价值，需要的朋友可以参考一下。






C++是一门面向对象的编程语言，理解 C++，首先要理解类（Class）和对象（Object）这两个概念。

C++ 中的类（Class）可以看做C语言中结构体（Struct）的升级版。结构体是一种构造类型，可以包含若干成员变量，每个成员变量的类型可以不同；可以通过结构体来定义结构体变量，每个变量拥有相同的性质...

			
		

	



                

              
                



	

		

			

				
					
【C++】类和对象

				
			

			

				

					iluo12的博客
				

				

					04-24
					
					2232
					
				

			

		

		

			
				
C++类和对象

			
		

	



                


  
              

                


	

		

			

				
					
c++ — 类和对象

				
			

			

				

					水澹澹兮生烟
				

				

					07-10
					
					3065
					
				

			

		

		

			
				
我们在学习C语言时知道，C语言是面向过程的语言，他关系的是是完成事情的过程，以函数进行驱动，在对于比较规模的程序来说，我们可以直接编写出一个mian'xiang'guo'cehng


			
		

	





	

		

			

				
					
C++入门

					
最新发布

				
			

			

				

					weixin_70238476的博客
				

				

					07-31
					
					763
					
				

			

		

		

			
				
想学C++的一定要看，提前掌握

			
		

	



		

			
		



	

		

			

				
					
C++类和对象

				
			

			

				

					wh22141334的博客
				

				

					07-18
					
					4044
					
				

			

		

		

			
				
c++中的类和对象

			
		

	





	

		

			

				
					
c++类和对象

				
			

			

				

					includeevey的博客
				

				

					10-06
					
					7671
					
				

			

		

		

			
				
全文将讲解《类和对象》，文章比较长，请慢慢观看！

			
		

	





	

		

			

				
					
C++程序设计_面向对象进阶_C++_

				
			

			

				

					09-30
				

			

		

		

			
				
1. **类与对象**：在C++中，类是创建对象的蓝图，定义了一组特性和行为。对象是类的实例，具有类定义的属性和方法。通过定义类，可以将数据和操作数据的方法封装在一起，实现信息隐藏，降低模块间的耦合度。  2. **...

			
		

	





	

		

			

				
					
C++语言程序设计实验答案_类与对象.doc

				
			

			

				

					09-29
				

			

		

		

			
				
C++语言程序设计实验答案_类与对象.doc

			
		

	





	

		

			

				
					
c++语言程序设计课件_C语言教程_C++程序设计--类与对象_

				
			

			

				

					09-30
				

			

		

		

			
				
"C++语言程序设计课件_C语言教程_C++程序设计--类与对象_"这个标题揭示了我们将深入探讨C++中的核心概念，特别是面向对象编程的关键元素。  在C++中，类是数据和操作数据的方法的集合，它定义了一组属性和行为。类是...

			
		

	





	

		

			

				
					
C++语言和面向对象有限元程序设计.rar_C++_C++有限元_有限元_有限元程序_程序设计

				
			

			

				

					07-14
				

			

		

		

			
				
C++语言和面向对象程序设计，有限元程序设计。

			
		

	





	

		

			

				
					
统计字母个数_类_C++_

				
			

			

				

					10-01
				

			

		

		

			
				
c++实现统计字母个数，面对对象的编程，应用类与对象，已封装

			
		

	





	

		

			

				
					
C++类与对象

				
			

			

				

					08-31
				

			

		

		

			
				
讲述了C++中的类与对象的基本概念

			
		

	





	

		

			

				
					
【c++】 类与对象

				
			

			

				

					博客小新
				

				

					09-01
					
					373
					
				

			

		

		

			
				
这篇内容是对 类与对象 有一个基础的认识，在c++里面类与对象是很重要的，这对于整个c++的学习起到一个关键的作用。如果 类与对象 的认识不够，后续的其他c++知识恐怕也很难理解到位，所以掌握类和对象是很关键的。这篇整理的知识，是对类和对象有一个最基础的了解。在今后的学习路上，希望与大家共勉。----加油！----

			
		

	





	

		

			

				
					
C++的类和对象

				
			

			

				

					Cosmicsea的博客
				

				

					05-21
					
					5316
					
				

			

		

		

			
				
C++面向对象的三大特性：封装、继承、多态



C++认为万事万物皆可为对象，对象有其属性和行为

具有相同性质的对象，可以抽象为类



封装

类在设计时，可以把属性和行为放在不同的权限下，加以控制

public：公共权限，类内可访问、类外可访问，
	protected：保护权限，类内可访问、类外不可访问，儿子可以访问父亲的保护内容
	private：私有权限，类内可访问、类外不可访问，儿子不可以访问父亲的私有内容
struct和class的区别在于

struct的默认权限是public
	cla

			
		

	





	

		

			

				
					
C++：类与对象

				
			

			

				

					做一只猫的博客
				

				

					08-10
					
					2763
					
				

			

		

		

			
				
1 面向对象
1.1三大特性
C++面向对象的三大特性为：封装、继承、多态
C++认为万事万物都皆为对象，对象上有其属性和行为
实例化：用类创建对象的过程
例如：
​	人可以作为对象，属性有姓名、年龄、身高、体重…，行为有走、跑、跳、吃饭、唱歌…
​	车也可以作为对象，属性有轮胎、方向盘、车灯…,行为有载人、放音乐、放空调…
​	具有相同性质的对象，我们可以抽象称为类，人属于人类，车属于车类
1.2 封装
1.2.1  封装的意义

将属性和行为作为一个整体，叫做类，来表现生活中的事物

属性 成员属性、成

			
		

	





	

		

			

				
					
C++入门：类与对象基础习题详解

				
			

			

				

					
				

			

		

		

			
				
C++ 类与对象是面向对象编程（Object-Oriented Programming, OOP）的基础概念，本文档主要针对初学者提供了一系列关于C++ 中类与对象的习题和解答。首先，我们来看填空题部分：  1. 在C++ 中，引入类定义的关键字是`...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  





	
打赏作者

	

		

		
			
		
		

		

			
大师兄电子工作室

			
你的鼓励将是我创作的最大动力

		

	

	

			

	

	

    ¥1
    ¥2
    ¥4
    ¥6
    ¥10
    ¥20
	

	

		

			

				

					扫码支付：¥1
				

				

					

					
					获取中
					

				

				

					
					
					扫码支付
				

			

		

		

			
您的余额不足，请更换扫码支付或充值

			
打赏作者

		

	



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值