一.构造函数和析构函数
“恢复出厂设置”
构造函数:初始化
析构函数:清理
如果没有定义的话,编译器自动给你弄,但是是空函数。
//1.1构造函数
//没有返回值,不用写void
//函数名与类名相同
//构造函数可以有参数,可以发生重载
//创建对象的时候,构造函数会自动调用,且只调用一次
//1.2析构函数(进行清理的操作)
//没有返回值,不用写void
//函数名: ~类名
//析构函数不可以有参数,不可以发生重载
//对象在销毁时,可以自动调用构造函数,且只调用一次
#include<iostream>
using namespace std;
#include<string>
#include<Math.h>
#include <cstdlib>//解决system不明确问题。
class Person
{
public:
//1.1构造函数
//没有返回值,不用写void
//函数名与类名相同
//构造函数可以有参数,可以发生重载
//创建对象的时候,构造函数会自动调用,且只调用一次
Person()
{
cout << "构造函数的调用" << endl;
}
//1.2析构函数(进行清理的操作)
//没有返回值,不用写void
//函数名: ~类名
//析构函数不可以有参数,不可以发生重载
//对象在销毁时,可以自动调用构造函数,且只调用一次
~Person()
{
cout << "析构函数的调用" << endl;
}
};
void test()
{
Person p;
}
int main()
{
//test();
Person p;
system("pause");
return 0;
}
————————————————————————
二.构造函数的分类及调用。
//1.构造函数的分类及调用
//分类
//按照参数分类: 有参构造 (默认构造)和 无参构造
//按照类型分类: 普通构造 和 拷贝构造
//1.括号法 简单好用,推荐!
Person p1;//默认构造函数调用
Person P2(10);//有参构造函数调用
Person P3(P2);//拷贝构造函数的调用
//注意事项1:
//调用默认构造函数时候,不加()
//Person p1();编译器会认为是一个函数的声明,不会认为在创建对象
//void p1(); 【类似】
cout << “P2的年龄是” << P2.age << endl;
cout << “P3的年龄是” << P3.age << endl;
//2.显示法
Person P1;//无参调用
Person P2 = Person(10);//有参调用
Person P3 = Person(P2);//拷贝构造
Person(10);// 匿名对象 特点:当前行执行结束后,系统直接立即收回匿名对象
cout << "aa";
//注意事项2:
//不要利用拷贝构造函数 初始化匿名对象
//Person(P3);//编译器认为:Person(P3)==Person P3; 对象的声明
//3.隐式构造法
Person P4 = 10;//等价为 Person P4 = Person(10);
Person P5 = P4;//拷贝构造
#include<iostream>
using namespace std;
#include<string>
#include<Math.h>
#include <cstdlib>//解决system不明确问题。
//1.构造函数的分类及调用
//分类
//按照参数分类: 有参构造 (默认构造)和 无参构造
//按照类型分类: 普通构造 和 拷贝构造
class Person
{
public:
//构造函数
Person()//无参 (普通)
{
cout << "无参构造函数的调用" << endl;
}
Person(int a)//有参 (普通)
{
age = a;
cout << "有参构造函数的调用" << endl;
}
//拷贝构造函数
Person(const Person& p)//有参(拷贝)
{
//将传入的人身上的所有属性拷贝到我身上
age = p.age;
cout << "拷贝构造函数的调用" << endl;
}
~Person()
{
cout << "析构函数的调用" << endl;
}
int age;
};
void test()//构造函数调用
{
//1.括号法 简单好用,推荐!
Person p1;//默认构造函数调用
Person P2(10);//有参构造函数调用
Person P3(P2);//拷贝构造函数的调用
//注意事项1:
//调用默认构造函数时候,不加()
//Person p1();编译器会认为是一个函数的声明,不会认为在创建对象
//void p1(); 【类似】
cout << "P2的年龄是" << P2.age << endl;
cout << "P3的年龄是" << P3.age << endl;
//2.显示法
Person P1;//无参调用
Person P2 = Person(10);//有参调用
Person P3 = Person(P2);//拷贝构造
Person(10);// 匿名对象 特点:当前行执行结束后,系统直接立即收回匿名对象
cout << "aa";
//注意事项2:
//不要利用拷贝构造函数 初始化匿名对象
//Person(P3);//编译器认为:Person(P3)==Person P3; 对象的声明
//3.隐式构造法
Person P4 = 10;//等价为 Person P4 = Person(10);
Person P5 = P4;//拷贝构造
}
int main()
{
test();
system("pause");
return 0;
}
—————————————————————————
三.拷贝构造函数的调用时机:
1.使用一个已经创建完毕的对象初始化一个新对象
2.值传递的方式给函数参数传值
3.值方式返回局部变量
#include<iostream>
using namespace std;
#include<string>
#include<Math.h>
#include <cstdlib>//解决system不明确问题。
class Person
{
public:
//构造函数
Person()//无参 (普通)
{
cout << "无参构造函数的调用" << endl;
}
Person(int a)//有参 (普通)
{
age = a;
cout << "有参构造函数的调用" << endl;
}
//拷贝构造函数
Person(const Person& p)//有参(拷贝)
{
//将传入的人身上的所有属性拷贝到我身上
age = p.age;
cout << "拷贝构造函数的调用" << endl;
}
~Person()
{
cout << "析构函数的调用" << endl;
}
int age;
};
//1.使用一个已经创建完毕的对象初始化一个新对象
void test01()
{
Person p1(10);
Person p3(p1);
cout << "p3的年龄" << p3.age << endl;
}
void dowork(Person p)
{
}
//2.值传递的方式给函数参数传值
void test02()
{
Person p;
dowork(p);//拷贝一个副本过来,两个p不是一回事。
}
Person dowork2()
{
Person p;
cout << (int*)&p << endl;//两个p不是一回事。
return p;
}
//3.值方式返回局部变量
void test03()
{
Person p = dowork2();
cout << (int*) &p << endl;//两个p不是一回事。
}
int main()
{
//test01();
//test02();
test03();
system("pause");
return 0;
}
————————————————————————
四.构造函数的调用规则
//1.默认情况下,创建一个类,c++编译器至少给一个类添加至少3个函数
//默认构造 (空实现)
//析构函数 (空实现)
//拷贝构造 (值拷贝*)*
//2.如果我们写了有参构造函数,编译器就不再提供默认构造,依然提供拷贝构造
//如果我们写了拷贝构造函数,编译器就不再提供其他构造了
#include<iostream>
using namespace std;
#include<string>
#include<Math.h>
#include <cstdlib>//解决system不明确问题。
//构造函数的调用规则
//1.默认情况下,创建一个类,c++编译器至少给一个类添加至少3个函数
//默认构造 (空实现)
//析构函数 (空实现)
//拷贝构造 (值拷贝)
//2.如果我们写了有参构造函数,编译器就不再提供默认构造,依然提供拷贝构造
//如果我们写了拷贝构造函数,编译器就不再提供其他构造了
class Person
{
public:
//构造函数
//Person()//无参 (普通)
//{
// cout << "无参构造函数的调用" << endl;
//}
//Person(int a)//有参 (普通)
//{
// age = a;
// cout << "有参构造函数的调用" << endl;
//}
//拷贝构造函数
Person(const Person& p)//有参(拷贝)
{
//将传入的人身上的所有属性拷贝到我身上
age = p.age; // 虽然没写被注释掉了,但是默认有他的
cout << "拷贝构造函数的调用" << endl;
}
~Person()
{
cout << "析构函数的调用" << endl;
}
int age;
};
//void test01()
//{
// Person p1;
// p1.age = 10;
// Person p3(p1);
// cout << "p3的年龄" << p3.age << endl;
//}
void test02()
{
Person p(1);
Person p2(p);
cout << "p2的年龄" << p2.age << endl;
}
int main()
{
//test01();
test02();
//test01();
system("pause");
return 0;
}
逻辑如图:
————————————————————————
五.浅拷贝与深拷贝
浅拷贝:简单的赋值操作,没有写拷贝函数时候会浅拷贝
深拷贝:自己new一个堆区空间,进行拷贝。
简言之: new 了就得 写拷贝构造函数。(深拷贝)
//析构函数,将堆区开辟的数据释放的操作
~Person()
{
//析构函数,将堆区开辟的数据释放的操作
if (m_Height == NULL)
{
delete m_Height;
m_Height = NULL;//防止野指针
}
cout << "析构函数的调用" << endl;
}
“奇怪的是我实操时候没有进行深拷贝也没有报错,为了严谨起来以后就这样规范写”
如下。
#include<iostream>
using namespace std;
#include<string>
#include<Math.h>
#include <cstdlib>//解决system不明确问题。
//深拷贝和浅拷贝
class Person
{
public:
Person()//
{
cout << "无参构造函数的调用" << endl;
}
Person(int a,int Height)
{
age = a;
m_Height = new int(Height);//指针接收堆区的数据
cout << "有参构造函数的调用" << endl;
}
//自己构造拷贝构造函数,解决浅拷贝带来的问题
Person(const Person& p)//有参(拷贝)
{
//m_Height = p.m_Height; 编译器的拷贝操作,会在释放堆区的时候出错。
age = p.age;
//深拷贝操作
m_Height = new int(*p.m_Height);
cout << "拷贝构造函数的调用" << endl;
}
~Person()
{
//析构函数,将堆区开辟的数据释放的操作
if (m_Height == NULL)
{
delete m_Height;
m_Height = NULL;//防止野指针
}
cout << "析构函数的调用" << endl;
}
int age;
int* m_Height;//身高
};
void test01()
{
Person p1(18,160);
cout << "p1" << p1.age <<"shengao" <<p1.m_Height<<endl;
Person p2(p1);
cout << "p2" << p2.age << "shengao" << p2.m_Height << endl;
}
int main()
{
test01();
//test02();
//test01();
system("pause");
return 0;
}
如果属性有堆区的数据,一定要构造拷贝函数,进行深拷贝,防止浅拷贝带来的 “重复释放堆区”的问题。
逻辑图:
六、初始化列表
相对传统初始化方式简单,代码短,加“:”
代码如下:
#include<iostream>
using namespace std;
#include<string>
#include<Math.h>
#include <cstdlib>//解决system不明确问题。
//初始化列表
class Person
{
public:
//传统初始化操作
//Person(int a,int b,int c)
//{
// m_a = a;
// m_b = b;
// m_c = c;
//}
//初始化列表初始化属性
Person(int a, int b, int c) :m_a(a), m_b(b), m_c(c)
{
}
int m_a;
int m_b;
int m_c;
};
void test01()
{
//传统初始化操作
//Person p(18,2,160);
//初始化列表初始化属性
Person p(1, 2, 160);
cout << "a " << p.m_a <<"b " <<p.m_b<<"c "<<p.m_c<<endl;
}
int main()
{
test01();
system("pause");
return 0;
}
七、类对象作为类成员
//其他类作为本类成员时,构造函数时候先构造类对象,再构造自身,析构函数的顺序相反。
格式:
class A{};
class B
{
A a;
};
#include<iostream>
using namespace std;
#include<string>
#include<Math.h>
#include <cstdlib>//解决system不明确问题。
class Phone
{
public:
Phone(string Pname)
{
m_Pname = Pname;
cout << "手机类构造出函数的调用" << endl;
}
~Phone()
{
cout << "手机类析构函数的调用" << endl;
}
string m_Pname;
};
class Person
{
public:
Person(string a, string b) :m_name(a), m_phone(b)//等价为Phone m_phone = b (隐式构造)
{
cout << "人类构造函数的调用" << endl;
}
~Person()
{
cout << "人类析构函数的调用" << endl;
}
string m_name;
Phone m_phone;
};
//其他类作为本类成员时,构造时候先构造类对象,再构造自身,析构函数的顺序相反。
void test01()
{
Person p("张故", "华为");
cout << p.m_name << "有" << p.m_phone.m_Pname << endl;
}
int main()
{
test01();
system("pause");
return 0;
}
八、静态成员
(一)、静态成员变量
//1.所有对象共享同一份数据,同时被改变
//2.在编译阶段分配内存
//3.类内声明,类外初始化
//4.静态成员变量也有访问权限
//因此有两种访问方式
//1.通过对象访问
Person p;
cout << p.m_A << endl;
//2.通过类名访问
cout << Person::m_A << endl;
#include<iostream>
using namespace std;
#include<string>
#include<Math.h>
#include <cstdlib>//解决system不明确问题。
//静态成员变量
class Person
{
public:
//1.所有对象共享同一份数据
//2.在编译阶段分配内存
//3.类内声明,类外初始化
static int m_A; //类内声明
//静态成员变量也有访问权限
private:
static int m_B;
};
int Person::m_A = 10;//类外初始化
int Person::m_B = 130;
void test01()
{
//静态成员变量 不属于某个对象,所有对象共享一份数据
Person p1;
cout << p1.m_A << endl;
Person p2;
p2.m_A = 112;
cout << p1.m_A << endl;//共享数据,同被改变
}
void test02()
{
//因此有两种访问方式
//1.通过对象访问
Person p;
cout << p.m_A << endl;
//2.通过类名访问
cout << Person::m_A << endl;
cout << Person::m_B << endl;//此处不可访问,证明有权限
}
int main()
{
test01();
test02();
system("pause");
return 0;
}
(二)、静态成员函数
//1.所有对象共享一个函数
//2.静态成员函数只能访问静态成员变量
//静态成员函数也有访问权限
//有两种访问方式
//1.通过对象访问
Person p;
p.func();
//2.通过类名访问
Person::func();
//Person::func2();类外访问不到私有静态成员函数。
#include<iostream>
using namespace std;
#include<string>
#include<Math.h>
#include <cstdlib>//解决system不明确问题。
//静态成员变量
class Person
{
//1.所有对象共享一个函数
//2.静态成员函数只能访问静态成员变量
public:
static void func()
{
m_A = 1;//静态成员函数 可以 访问静态成员变量
//m_B = 2;//静态成员函数 不可以 访问非静态成员变量,因为不能区分到底是哪个对象的m_B属性
cout << "static void func的调用" << endl;
}
static int m_A; //类内声明
int m_B;
//静态成员函数也有访问权限
private:
static void func2()
{
cout << " static void func2()的调用" << endl;
}
};
int Person::m_A = 10;//类外初始化
void test02()
{
//有两种访问方式
//1.通过对象访问
Person p;
p.func();
//2.通过类名访问
Person::func();
//Person::func2();类外访问不到私有静态成员函数。
}
int main()
{
//test01();
test02();
system("pause");
return 0;
}
九、c++对象模型和this指针
c++对象模型:
成员函数和成员变量分开存储,只有非静态变量才属于类的对象上。
注意:
class Person
{
int m_A;//非静态成员变量, 属于类的对象上 Only one
static int m_B;//静态成员变量, 不属于类的对象上
void func(){} //非静态成员函数, 不属于类的对象上
static void func1(){}//静态成员函数, 不属于类的对象上
};
//空对象占用的内存为 1
//C++编译器会给每个空对象也分配一个字节的空间,是为了区分空对象占内存的位置。
//每个空对象也应该有一个有一个独一无二的内存地址。
#include<iostream>
using namespace std;
#include<string>
//成员变量和成员函数分开存储
class Person
{
int m_A;//非静态成员变量, 属于类的对象上 Only one
static int m_B;//静态成员变量, 不属于类的对象上
void func(){} //非静态成员函数, 不属于类的对象上
static void func1(){}//静态成员函数, 不属于类的对象上
};
int Person::m_B = 10;//类外初始化
void test02()
{
Person p;
//空对象占用的内存为 1
//C++编译器会给每个空对象也分配一个字节的空间,是为了区分空对象占内存的位置。
//每个空对象也应该有一个有一个独一无二的内存地址。
cout << sizeof(p) << endl;
}
void test01()
{
Person p;
cout << sizeof(p) << endl;
}
int main()
{
test01();
//test02();
system("pause");
return 0;
}
this指针
//this指针概念
//每个非静态成员函数只会生成一份函数实例,即多个同类型的对象会共用一块代码
//this指针可以解决! this指针指向 被调用的成员函数 所属的对象
//this指针 是隐含 每一个非静态成员函数 内的一种指针
//this指针的俩用途
//1、解决名称冲突。
//2.返回对象本身用 *this
#include<iostream>
using namespace std;
#include<string>
//this指针概念
//每个非静态成员函数只会生成一份函数实例,即多个同类型的对象会共用一块代码
//this指针可以解决! this指针指向 被调用的成员函数 所属的对象
//this指针 是隐含 每一个非静态成员函数 内的一种指针
class Person
{
public:
Person(int age)
{
//this指针指向 被调用的成员函数 所属的对象
this->age = age;//解决名称冲突。
}
Person& Personageadd(Person& p)//如果不是不返回引用,以值的方式返回,那么每次都会copy一个P,于是只加了一次,返回的是20
{
this->age += p.age;
return *this;//返回对象本身用*this
}
int age;
};
//this指针的俩用途
//1、解决名称冲突。
void test01()
{
Person p1(18);
cout << "p1的年龄:" << p1.age << endl;
}
//2.返回对象本身用*this
void test02()
{
Person p1(10);
Person p2(10);
//链式编程思想
p2.Personageadd(p1).Personageadd(p1).Personageadd(p1);
cout << "p2的年龄:" << p2.age << endl;
}
int main()
{
//test01();
test02();
system("pause");
return 0;
}
十、空指针访问成员函数
空指针也可以调用成员函数,但是需要考虑有没有调用this指针*(空指针无法调用this指针)
如果有,就需要修改代码,以保证代码的健壮性*
#include<iostream>
using namespace std;
#include<string>
//空指针调用成员函数
class Person
{
public:
void showClassName()
{
cout << "这是人类" << endl;
}
void showPersonAge()
{
//报错原因是传入的指针是NULL
if (this == NULL)
{
return;
}
cout << "age" << this->m_age << endl; //m_age默认加了个this->m_age
}
int m_age;
};
void test01()
{
Person* p = NULL;
p->showClassName();
p->showPersonAge();
}
void test02()
{
}
int main()
{
test01();
//test02();
system("pause");
return 0;
}
十一、常对象和常函数
1.常函数
在成员函数后面加const , 修饰的是this指向,让指针指向的值也不可修改
想修改时:
mutable int m_b;//特殊变量,即时在常函数中,也可以修改
class Person
{
public:
//都会隐含this指针,this指针是指针常量, 指针的指向不可改变
//const Person *const this;
//在成员函数后面加const , 修饰的是this指向,让指针指向的值也不可修改
void showPerson() const
{
//this->m_age = 199;
this->m_b = 11;
//this = NULL;//this指针指向的值不可修改
}
void show()
{
}
int m_age;
mutable int m_b;//特殊变量,即时在常函数中,也可以修改
};
2.常对象
void test02()
{
const Person p; //在对象前加const ,变为常对象
p.m_age = 123;
p.m_b = 23;//m_b是特殊值,在常对象也可以修改
p.show();//常对象不可调用普通成员函数,因为普通成员函数可以修改属性
//常对象只能调用常函数。
}
总和代码如下:
#include<iostream>
using namespace std;
#include<string>
//常函数
class Person
{
public:
//都会隐含this指针,this指针是指针常量, 指针的指向不可改变
//const Person *const this;
//在成员函数后面加const , 修饰的是this指向,让指针指向的值也不可修改
void showPerson() const
{
//this->m_age = 199;
this->m_b = 11;
//this = NULL;//this指针指向的值不可修改
}
void show()
{
}
int m_age;
mutable int m_b;//特殊变量,即时在常函数中,也可以修改
};
void test01()
{
Person p;
p.showPerson();
}
//常对象
void test02()
{
const Person p; //在对象前加const ,变为常对象
p.m_age = 123;
p.m_b = 23;//m_b是特殊值,在常对象也可以修改
p.show();//常对象不可调用普通成员函数,因为普通成员函数可以修改属性
//常对象只能调用常函数。
}
int main()
{
test01();
//test02();
system("pause");
return 0;
}
我的天,终于把对象特性学完了,撒花撒花~