前言：
之前，我们已经通过经历了类和对象（上）和类和对象（中）的学习，使我们对类和对象这一概念打下了坚实的基础，今天我们要做的便是对类和对象进行收尾工作，本篇之后关于类和对象的全部知识便讲解完毕了。接下来，我们正式进入今天的学习。
本文目录
通过之前的学习，我们不难发现对于构造函数，不知道小伙伴有没有觉得对于这个构造函数的设计，祖师爷在开始设计的时候是不是设计太复杂了呀！
通过之前，我们已经知道构造函数对于内置类型不会处理，而对于自定义类型则会去调用它的默认构造。原因是什么大家现在还知道吗？
那这又是为什么呢？（我们不可以不管它们吗）
我们知道在创建对象时，编译器通过调用构造函数，给对象中各个成员变量一个合适的初始值。
class Date
{
public:
Date(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}
private:
int _year;
int _month;
int _day;
};👉因此，基于上述原因，【C++】就引入了初始化列表这个概念！！！
首先，我们先来看看关于初始化列表的基本格式：
初始化列表
我们以时间类进行举例，给出初始化列表的相应表示，具体如下：
class Date
{
public:
Date(int year, int month, int day)
: _year(year)
, _month(month)
, _day(day)
{}
private:
int _year;
int _month;
int _day;
};
初始化列表规定了，既然它是每个成员定义的地方，因此你在这不管写不写它自动的都会走初始化列表，不管是内置类型还是自定义类型都是如此，因为这是规定的每个成员定义的地方。
👉【注意】.^◡^.
1. 每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)
2. 类中包含以下成员，必须放在初始化列表位置进行初始化：
class A
{
public:
A(int a)
:_a(a)
{}
private:
int _a;
};
class B
{
public:
B(int a, int ref)
:_aobj(a)
,_ref(ref)
,_n(10)
{}
private:
A _aobj; // 没有默认构造函数
int& _ref; // 引用
const int _n; // const
};
因此，大家记住一点，那就是尽量使用初始化列表！！！
大家在看以下代码就可以清晰的看出了：
class Time
{
public:
Time(int hour = 0)
:_hour(hour)
{
cout << "Time()" << endl;
}
private:
int _hour;
};
class Date
{
public:
Date(int day)
{}
private:
int _day;
Time _t;
};
int main()
{
Date d(1);
return 0;
}
输出结果为：
接要来要给大家说的一点便是，这点很容易迷糊大家:
具体什么意思呢？我们通过代码来给大家具体的说明，具体如下，大家看如下代码输出的结果是什么：
class A
{
public:
A(int a)
:_a1(a)
, _a2(_a1)
{}
void Print()
{
cout << _a1 << " " << _a2 << endl;
}
private:
int _a2;
int _a1;
};
int main()
{
A aa(1);
aa.Print();
return 0;
}
好，废话不多说我们直接给出结果，具体如下，大家是否能够想得明白呢？：
上述结果不难发现这一点，这个大家稍微记住就可以了。做题时遇到要会即可。
在学习这个关键字之前，我先通过代码来带大家先了解为什么会引入这个关键字，它的作用是什么呢？
class A
{
public:
A(int a)
:_a1(a)
{
cout << "A(int a)" << endl;
}
A(const A& aa)
:_a1(aa._a1) //注意拷贝构造也有初始化列表
{
cout << "A(const A & a)" << endl;
}
private:
int _a1;
};
int main()
{
A aa1(1); //构造函数
A aa2 = 1; //隐式类型转换 构造+拷贝构造+优化 ——>构造
return 0;
}解析：
对于上述的两种初始化的方法，我相信大家应该都知道，但是各位懂得其中的原理吗？像【aa2】那样写的意义是什么呢？
大家结合这个先来理解：
int i = 1;
double j = i; //隐式类型转换
有了这个做铺垫，那上面的【1】和【aa2】之间是怎么发生转换的呢？其实是一样的道理，此时这里的这个临时变量就是【A】类型的，这个临时对象再去拷贝构造：
接下来我们验证一下，按照我上面说的，【aa1】是有一个构造，【aa2】应该是有一个构造再加一个拷贝构造，接下来我进行编译看结果是不是那样。
咦......两个构造是有，但是为什么拷贝构造没有呢？这是什么原因呢？🤔
此时可能有好奇的小伙伴就会问了，你是怎么知道这里有临时对象的呢？不要急，接下来我就给大家验证一下。🤥
接下来，我们这样做，看如下代码：
A& ref = 10;此时会不会编译成功呢？
此时我们发现加上【const】之后就可以了，那么为什么呢？
因此，上述我们不难得出一个结论，对于单参数的构造函数，此时这里发生的是隐式类型转换。构造函数不仅可以构造与初始化对象，对于单个参数或者除第一个参数无默认值其余均有默认值 的构造函数，还具有类型转换的作用。
但是此时我们并不想它发生这样的转换有什么方法吗？——这时就引出了【explicit】这个关键字。
当我们加上这个关键字之后，在当我们去编译时就会报错：
例如:
class A
{
public:
A(int a, int a2)
:_a1(a)
, _a2(a2)
{
cout << "A(int a)" << endl;
}
A(const A& aa)
:_a1(aa._a1)
{
cout << "A(const A & a)" << endl;
}
private:
int _a1;
int _a2;
};
int main()
{
// 多参数构造函数 C++11
A aa3(1, 1);
A aa4 = { 2,2 }; //注意这里是花括号
const A &ref = { 2, 2 };
return 0;
}
总结：
接下来，我们通过一个来具体看看
using std::cout; //解决命名冲突
using std::endl;
int count = 0; //传统方式定义一个全局变量
class A
{
public:
A(int a = 0)
{
++count;
}
A(const A& aa)
{
++count;
}
};
void func(A a)
{}
int main()
{
A aa1;
A aa2(aa1);
func(aa1);
A aa3 = 1;
cout << count << endl;
return 0;
}解析：
此时，就会出现一个命名冲突的问题，跟库中的发生了冲突，那么如何解决呢？
using std::cout;
using std::endl;
打印结果为：
但是大家上述写法是否存在问题呢？因为全局变量在哪个地方都可以改，没有封装起来，而 C++ 是很注重数据的封装的。假如我们“手欠”，加上了这样几行代码，此时结果是什么呢？
此时，我们就会发现，这时的结果显然就出错了呀！！那怎么解决呢？我们就可以通过 【static 】成员变量来解决这个问题。
class A
{
public:
A(int a = 0)
{
++count;
}
A(const A& aa)
{
++count;
}
//private:
static int count; //属于所有对象，属于整个类
};
int A::count = 0;// 定义初始化
void func(A a)
{}
int main()
{
A aa1;
A aa2(aa1);
func(aa1);
A aa3 = 1;
cout << A::count << endl; //注意这里的访问方式
cout << aa2.count << endl;
cout << aa3.count << endl;
return 0;
}
注意：
上述虽然解决了全局变量的问题，又带来了另一个问题：【static 】成员变量是公有的，没有将其封装起来。那有没有更好的方式呢？
class A
{
public:
A(int a = 0)
{
++count;
}
A(const A& aa)
{
++count;
}
static int GetACount()
{
return count;
}
private:
static int count; //属于所有对象，属于整个类
};
int A::count = 0;// 定义初始化
void func(A a)
{}
int main()
{
A aa1;
A aa2(aa1);
func(aa1);
A aa3 = 1;
cout << aa3.GetACount() << endl;
return 0;
}此时，我们打印一下结果，看是否正确:
特性
1. 静态成员函数可以调用非静态成员函数吗？
2. 非静态成员函数可以调用类的静态成员函数吗？
3.静态成员函数与普通成员函数的根本区别
这里给大家提供一个题，大家有兴趣可以按照上述思想去进行解答：
1.求1+2+3+...+n，要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判 断语句
首先解答为什么引入友元🧐：
这个在前面我们已经提过，当我们尝试去重载【operator<<】，然而发现没办法将【operator<<】重载成成员函数。因为【cout】的 输出流对象和隐含的this指针在抢占第一个参数的位置。【this】指针默认是第一个参数也就是左操作 数了。但是实际使用中【cout】需要是第一个形参对象，才能正常使用。所以要将【operator<<】重载成全局函数。但又会导致类外没办法访问成员，此时就需要友元来解决。
https://www.nowcoder.com/practice/7a0da8fc483247ff8800059e12d7caf1?tpId=13&tqId=11200&tPage=3&rp=3&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-rankingclass Date
{
friend ostream& operator<<(ostream& _cout, const Date& d);
friend istream& operator>>(istream& _cin, Date& d);
public:
Date(int year = 1900, int month = 1, int day = 1)
: _year(year)
, _month(month)
, _day(day)
{}
private:
int _year;
int _month;
int _day;
};
ostream& operator<<(ostream& _cout, const Date& d)
{
_cout << d._year << "-" << d._month << "-" << d._day;
return _cout;
}
istream& operator>>(istream& _cin, Date& d)
{
_cin >> d._year;
_cin >> d._month;
_cin >> d._day;
return _cin;
}
int main()
{
Date d;
cin >> d;
cout << d << endl;
return 0;
}
注意事项：
说明：
除此之外，两个类要共享数据的时候也可以使用友元函数！！！
定义友元类的语句格式如下：
class Time
{
friend class Date; // 声明日期类为时间类的友元类，则在日期类中就直接访问Time类
中的私有成员变量
public:
Time(int hour = 0, int minute = 0, int second = 0)
: _hour(hour)
, _minute(minute)
, _second(second)
{}
private:
int _hour;
int _minute;
int _second;
};
class Date
{
public:
Date(int year = 1900, int month = 1, int day = 1)
: _year(year)
, _month(month)
, _day(day)
{}
void SetTimeOfDate(int hour, int minute, int second)
{
// 直接访问时间类私有的成员变量
_t._hour = hour;
_t._minute = minute;
_t._second = second;
}
private:
int _year;
int _month;
int _day;
Time _t;
};注意事项：
概念：
接下来，我举个例子，大家看以下代码最终的结果是多少：
class A
{
private:
int m;
public:
class B // B天生就是A的友元
{
public:
void inner(const A& a)
{
cout << a.m << endl;//OK
}
};
};
int main()
{
A aa;
cout << sizeof(aa) << endl;
return 0;
}直接打印看最终的结果：
外部类和内部类是相当于两个独立的类，只是内部类的访问受外部类的类域和访问限定符的限制。那么我们要对内部域进行操作时应该怎么办呢？
具体可以像以下这种方式：
class A
{
private:
int m;
public:
class B // B天生就是A的友元
{
public:
void inner(const A& a)
{
cout << a.m << endl;//OK
}
};
};
int main()
{
A aa;
cout << sizeof(aa) << endl;
A::B b; //
b.inner(A());
return 0;
}此时有小伙伴就会说内部类是不是没什么用呢这样看来？其实吧，不能说没用，只能说功能比较小而已对于C++来说，对于java使用这个就很频。
我们举个例子来看看：
class A
{
private:
static int n;
int m;
public:
class B // B天生就是A的友元
{
public:
void inner(const A& a)
{
cout << n << endl;//OK
cout << a.m << endl;//OK
}
};
};
int A::n = 10;
int main()
{
A aa;
cout << sizeof(aa) << endl;
A::B b;
b.inner(A());
return 0;
}
解析：
我们在A里面定义了私有的n，此时B是可以直接访问的，我们编译看看是不是像我说的这样
但是如果B是一个全局的类，此时再去访问还可以吗？结果是报错的
总结：
1.内部类可以定义在外部类的public、protected、private都是可以的。
2.sizeof(外部类)=仅仅是外部类的大小，和内部类没有任何关系。内部类的大小也和外部类没有关系
3.内部类可以直接访问外部类中的任何权限的static成员，不需要通过外部类的对象或类名来访问。
定义：
其实这个我们在上述讲解生成临时对象的时候就该给大家提一下，我在这里单独放在了一部分来给大家讲解。接下来我们还是通过代码来进行认识：
当我们定义对象时，最常见的就是下面这种：
但是当我们这样定义时还可以吗？
那这样呢？
接下来我们一个一个看。
class A
{
public:
A(int a = 0)
:_a(a)
{
cout << "A(int a)" << endl;
}
A(const A& aa)
:_a(aa._a)
{
cout << "A(const A& aa)" << endl;
}
A& operator=(const A& aa)
{
cout << "A& operator=(const A& aa)" << endl;
if (this != &aa)
{
_a = aa._a;
}
return *this;
}
~A()
{
cout << "~A()" << endl;
}
private:
int _a;
};
void func1(A aa)
{
}
void func2(const A& aa) //注意临时变量具有常性
{
}首先对于传值传参来说：
接下来对于传引用传参来说呢：
结论：
那对于这两个呢？
A func3()
{
A aa;
return aa;
}
int main()
{
func3();
A aa2 = func3();
return 0;
}
我给大家画图进行理解：
接下来，给大家看一组代码，大家觉得哪种好些呢？
int main()
{
func3();
A aa2 = func3();
cout << "---------------------------------------" << endl;
A aa3;
aa3 = func3();
return 0;
}
解析 ：
我们先直接打印看结果：
此时大家发现没有，二者存在的区别是多么的巨大。
紧接着还有这种情况
A func4()
{
return A();
}
int main()
{
func4();
A aa2 = func4();
return 0;
}
这个样例的最终结果是什么呢？我们先直接打印看最终的结果：
解析：
结论：
具体的还可以参考一本书：《深度探索C++ 对象模型》
现实生活中的实体计算机并不认识，计算机只认识二进制格式的数据。如果想要让计算机认识现 实生活中的实体，用户必须通过某种面向对象的语言，对实体进行描述，然后通过编写程序，创 建对象后计算机才可以认识。比如想要让计算机认识洗衣机，就需要：
到此，关于类和对象的所有的知识便全部讲完了！！大家都掌握了吗？😉
接下来我们总结一下类和对象都学到了什么：
在类和对象阶段，大家一定要体会到这样的观点：
最后，如果本文对您有帮助的话，记得点赞三连哟！！！
总的来说，我对ruby还比较陌生，我正在为我正在创建的对象编写一些rspec测试用例。许多测试用例都非常基础，我只是想确保正确填充和返回值。我想知道是否有办法使用循环结构来执行此操作。不必为我要测试的每个方法都设置一个assertEquals。例如:describeitem,"TestingtheItem"doit"willhaveanullvaluetostart"doitem=Item.new#HereIcoulddotheitem.name.shouldbe_nil#thenIcoulddoitem.category.shouldbe_nilendend但我想要一些方法来使用
在控制台中反复尝试之后，我想到了这种方法，可以按发生日期对类似activerecord的(Mongoid)对象进行分组。我不确定这是完成此任务的最佳方法，但它确实有效。有没有人有更好的建议，或者这是一个很好的方法？#eventsisanarrayofactiverecord-likeobjectsthatincludeatimeattributeevents.map{|event|#converteventsarrayintoanarrayofhasheswiththedayofthemonthandtheevent{:number=>event.time.day,:event=>ev
我有一个表单，其中有很多字段取自数组(而不是模型或对象)。我如何验证这些字段的存在？solve_problem_pathdo|f|%>... 最佳答案 创建一个简单的类来包装请求参数并使用ActiveModel::Validations。#definedsomewhere,atthesimplest:require'ostruct'classSolvetrue#youcouldevencheckthesolutionwithavalidatorvalidatedoerrors.add(:base,"WRONG!!!")unlesss
好的，所以我的目标是轻松地将一些数据保存到磁盘以备后用。您如何简单地写入然后读取一个对象？所以如果我有一个简单的类classCattr_accessor:a,:bdefinitialize(a,b)@a,@b=a,bendend所以如果我从中非常快地制作一个objobj=C.new("foo","bar")#justgaveitsomerandomvalues然后我可以把它变成一个kindaidstring=obj.to_s#whichreturns""我终于可以将此字符串打印到文件或其他内容中。我的问题是，我该如何再次将这个id变回一个对象？我知道我可以自己挑选信息并制作一个接受该信
如果您尝试在Ruby中的nil对象上调用方法，则会出现NoMethodError异常并显示消息:"undefinedmethod‘...’fornil:NilClass"然而，有一个tryRails中的方法，如果它被发送到一个nil对象，它只返回nil:require'rubygems'require'active_support/all'nil.try(:nonexisting_method)#noNoMethodErrorexceptionanymore那么try如何在内部工作以防止该异常？ 最佳答案 像Ruby中的所有其他对象
我在Rails工作并有以下类(class):classPlayer当我运行时bundleexecrailsconsole然后尝试:a=Player.new("me",5.0,"UCLA")我回来了:=>#我不知道为什么Player对象不会在这里初始化。关于可能导致此问题的操作/解释的任何建议？谢谢，马里奥格 最佳答案 havenoideawhythePlayerobjectwouldn'tbeinitializedhere它没有初始化很简单，因为你还没有初始化它!您已经覆盖了ActiveRecord::Base初始化方法，但您没有调
我有一个服务模型/表及其注册表。在表单中，我几乎拥有服务的所有字段，但我想在验证服务对象之前自动设置其中一些值。示例:--服务Controller#创建Action:defcreate@service=Service.new@service_form=ServiceFormObject.new(@service)@service_form.validate(params[:service_form_object])and@service_form.saverespond_with(@service_form,location:admin_services_path)end在验证@ser
下面例子中的Nested和Child有什么区别？是否只是同一事物的不同语法？classParentclassNested...endendclassChild 最佳答案 不，它们是不同的。嵌套:Computer之外的“Processor”类只能作为Computer::Processor访问。嵌套为内部类(namespace)提供上下文。对于ruby解释器Computer和Computer::Processor只是两个独立的类。classComputerclassProcessor#Tocreateanobjectforthisc
我想让一个yaml对象引用另一个，如下所示:intro:"Hello,dearuser."registration:$introThanksforregistering!new_message:$introYouhaveanewmessage!上面的语法只是它如何工作的一个例子(这也是它在thiscpanmodule中的工作方式。)我正在使用标准的rubyyaml解析器。这可能吗？ 最佳答案 一些yaml对象确实引用了其他对象:irb>require'yaml'#=>trueirb>str="hello"#=>"hello"ir
假设我有一个FireNinja我的数据库中的对象，使用单表继承存储。后来才知道他真的是WaterNinja.将他更改为不同的子类的最干净的方法是什么？更好的是，我很想创建一个新的WaterNinja对象并替换旧的FireNinja在数据库中，保留ID。编辑我知道如何创建新的WaterNinja来self现有FireNinja的对象，我也知道我可以删除旧的并保存新的。我想做的是改变现有项目的类别。我是通过创建一个新对象并执行一些ActiveRecord魔法来替换行，还是通过对对象本身做一些疯狂的事情，或者甚至通过删除它并使用相同的ID重新插入来做到这一点，这是问题的一部分。