- 使用 Spring Initializr 创建 Spring Boot 应用程序
- 在Spring Boot中配置Cassandra
- 在 Spring Boot 上配置 Tomcat 连接池
- 将Camel消息路由到嵌入WildFly的Artemis上
哈喽大家好,我是鹿 九 丸 \color{red}{鹿九丸}鹿九丸,今天给大家带来的是类和对象(下)。
如果大家在看我的博客的过程中或者学习的过程中以及在学习方向上有什么问题或者想跟我交流的话可以加我的企鹅号:2361038962 \color{red}{2361038962}2361038962,或者寄邮件到相应的邮箱里:2361038962 @ q q . c o m \color{red}{2361038962@qq.com}2361038962@qq.com,我会尽量帮大家进行解答!
在创建对象时,编译器通过调用构造函数,给对象中各个成员变量一个合适的初始值。
class Date
{
public:
Date(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}
private:
int _year;
int _month;
int _day;
};
虽然上述构造函数调用之后,对象中已经有了一个初始值,但是不能将其称作为类对象成员的初始化,构造函数体中的语句只能将其称作为赋初值,而不能称作初始化。因为初始化只能初始化一次,而构造函数体内可以多次赋值。
初始化列表:以一个冒号开始,接着是一个以逗号分隔的数据成员列表,每个"成员变量"后面跟一个放在括号中的初始值或表达式。
//函数体内初始化
Date(int year = 1, int month = 1, int day = 1)
{
_year = year;
_month = month;
_day = day;
}
//初始化列表
Date(int year = 1, int month = 1, int day = 1)
:_year(year)
, _month(month)
, _day(day)
{
//此时大括号中还能放东西
}
//我们甚至可以这样混着用
Date(int year = 1, int month = 1, int day = 1)
:_year(year)
, _month(month)
{
_day = day;
}
结论:初始化列表可以认为就是对象成员定义的地方。
【注意】
int iref = 10;
class A
{
public:
A(int a)
:_a(a)
{}
private:
int _a;
};
class B
{
public:
B(int a)
:_aobj(a)
, _ref(iref)
, _n(10)
{}
private:
A _aobj; // 没有默认构造函数
int& _ref; // 引用
const int _n; // const
};
问:对于没有默认构造函数的自定义类型的成员,假如不采用初始化列表的方式,我们还有什么办法来对其进行初始化?
答:
B(int a)
{
A aa(a);//A是自定义类型的类型名
_aa = aa;//_aa是自定义类型的成员变量名
}
注意:初始化列表中的参数可以有四种来源:
A(int a)
:_a(a)//_a是成员变量
{
}
A()
:_ref(iref)//ref是成员变量
{
}
A()
:_b(10)//_b是成员变量
{
}
class A
{
public:
A(int a)
{
}
private:
int _a = 10;
};
//此时我们并未显式写出初始化列表,但上面的代码在编译器看来应该是像下面一样的
class A
{
public:
A(int a)
:_a(10)
{
}
private:
int _a = 10;
};
注意点1:
下面这种写法是错误的:
class A
{
public:
A(int a)
:_a(a = 10)
{
cout << _a << endl;
}
private:
int _a;
};
int main()
{
A a1;
return 0;
}
这种写法编译器会报错,编译器会提示没有合适的默认构造函数可用,于是我们进行下面的修改:
class A
{
public:
A(int a = 20)
:_a(a = 10)
{
_a = a;
cout << a << endl;
cout << _a << endl;
}
private:
int _a;
};
int main()
{
A a1;
return 0;
}
输出结果如下:
分析:初始化列表中的赋值表达式a = 10
成功执行了,所以a被赋值给了10,同时返回值a即10将_a初始化为10,然后再执行_a = a
,这个语句执行了又相当于没有执行,并没有对最终结果产生影响。
再看下面的代码:
class A
{
public:
A(int a = 20)
:_a(a = 10)
{
_a = a;
cout << a << endl;
cout << _a << endl;
}
private:
int _a;
};
int main()
{
A a1(50);
return 0;
}
输出结果:
分析:50被赋值给形参a,所以并没有对最终的结果产生任何的影响。
此时再看下面的代码:
class A
{
public:
A(int a = 20)
:_a(a = 10)
{
_a = a;
cout << a << endl;
cout << _a << endl;
}
private:
int _a = 50;
};
int main()
{
A a1;
return 0;
}
输出结果:
输出结果仍然为10,此时我们可以得出一个结论:声明中初始化给的缺省值的优先级(_a = 50)比我们在初始化列表中显式给的a的优先级要低。声明中给的初始化的值是备用选择。类似于我们通常定义的函数中的缺省值一样。
结论:C++11在类的定义时对于成员变量给的缺省值是作用在初始化列表中的。
结论:初始化列表无论什么情况下都会走一遍,无论我们是否显式的给出。无论我们给的构造函数是否会形成默认构造函数,编译器都会在初始化列表中对自定义类型调用它的默认构造函数进行初始化。例如下面的代码:
class Time
{
public:
Time()
{
_hour = 1;
_minute = 1;
cout << _hour << "-" << _minute << endl;
}
private:
int _hour;
int _minute;
};
class Date
{
public:
Date(int year,int month,int day)
{
_year = year;
_month = month;
_day = day;
cout << _year << "-" << _month << "-" << _day;
}
private:
int _year;
int _month;
int _day;
Time t1;
};
int main()
{
Date d1(2022, 5, 23);
return 0;
}
程序运行结果:
分析:我们上面的Date构造函数并不是三种默认构造函数的一种,但还是对自定义类型调用了自定义类型成员变量t1即Time类的默认构造函数。
注意:之前我们提到,有三种默认构造函数:全缺省构造函数、无参构造函数、我们不写时编译器默认生成的构造函数,无论是上面的哪一种,都会对自定义类型默认调用它们的构造函数,这个过程就是在初始化列表完成的,至于内置类型,因为没有值去初始化,所以呈现出毫无意义的数值。
注意下面一种情况:
class Date
{
public:
Date(const Date& q)//拷贝构造函数
{}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d1;
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();
}
A. 输出1 1
B. 程序崩溃//一般是野指针之类的出现
C. 编译不通过
D. 输出1 随机值
运行结果:
所以正确答案应该是D,为什么?因为成员变量在初始化列表中的初始化顺序只和成员变量在类中的声明的顺序有关,在上面的例子中,_a2先声明的,所以在初始化列表中先执行的是\_a2(\_a1)
(此时_a1是随机值,因为并没有进行初始化),所以_a2是随机值,然后再执行的是\_a1(a)
,然后_a1被初始化为1,所以输出结果为1 随机值
。
构造函数不仅可以构造与初始化对象,对于单个参数的构造函数,还具有类型转换的作用。
class Date
{
public:
Date(int year)
:_year(year)
{}
private:
int _year;
};
void TestDate()
{
Date d1(2022);
// 用一个整形变量给日期类型对象赋值
// 实际编译器背后会用2022构造一个无名对象,最后用无名对象给d2对象进行赋值
Date d2 = 2022;
}
画图来理解:
在上面的这个过程中会调用两个函数:构造函数 + 拷贝构造(后面同类型变量的赋值是调用的是拷贝构造函数,因为是创建一个新的对象d2)
当然,在这个地方很多编译器会进行一个优化,会直接使用2022来构造一个Date类型的d2变量,省去了中间类型转换和临时变量的过程,只会调用一次构造函数。
explicit关键字的作用:用explicit修饰构造函数,将会禁止单参构造函数的隐式转换。。即无法将int类型转换成Date类型生成临时变量,继续运行上面的代码程序会报错,因为无法进行类型转换的操作。
看下面的代码:
class Date
{
public:
Date(int year)
{
_year = year;
}
private:
int _year;
};
void TestDate()
{
Date d1(2022);
Date& d2 = 2022;
}
int main()
{
TestDate();
return 0;
}
上面的代码运行后会出现问题,为什么?因为临时变量具有常性,不能被普通的引用所引用,这属于权限的扩大,如果想要引用临时变量,只能用常引用来引用,像下面代码所演示:
class Date
{
public:
Date(int year)
{
_year = year;
}
private:
int _year;
};
void TestDate()
{
Date d1(2022);
const Date& d2 = 2022;
}
int main()
{
TestDate();
return 0;
}
注意:这个临时变量被引用之后只有出了作用域之后才会被彻底销毁!
那么这种语法有什么用呢?看下面的代码:
void Func(const std::string& s)
{
}
int main()
{
std::string s1 = "hello";
Func(s1);//这种传参可以是毋庸置疑的
Func("hello");//有了临时变量进行隐式类型转换后这种传参也变得合法,且使传参变得更加方便
//"hello"发生了隐式类型转换后形成了一个临时变量,然后这个临时变量具有常性,类型为const string,所以必须用常引用来接收
}
声明为static的类成员称为类的静态成员,用static修饰的成员变量,称之为静态成员变量;用static修饰的成员函数,称之为静态成员函数。静态的成员变量一定要在类外进行初始化
面试题:实现一个类,计算程序中创建出了多少个类对象。
首先先看下面一个面试题,在下面的程序代码中,类型A的拷贝和构造函数被调用了多少次?
class A{};
A Func(A a)
{
A copy(a);
return copy;
}
int main()
{
A a1;
A a2 = Func(a1);
}
我们通过修改下面的代码就能够计算出调用次数:
int count = 0;
class A
{
public:
A()
{
count++;
}
A(const A& aa)
{
count++;
}
};
但是全局变量并不好,因为全局变量一般定义在.h文件里,常常会包含在其它的.cpp文件中,所以往往在项目中容易出现问题,我们推荐用静态成员变量:
class A
{
public:
void Print()
{
cout << _count << endl;//类内直接访问即可
}
A()
{
count++;
}
A(const A& aa)
{
count++;
}
private:
static int _count;//声明
};
int A::_count = 0;//定义,静态成员变量只能在类外定义
//假如_count是public权限的,在类外有两种访问方式:
Date d1;
d1._count;//通过具体某个类的实例化对象来进行访问
A::_count;//通过类来进行访问
问:静态成员变量和普通成员变量有什么区别?
答:静态成员变量不占用栈区上的空间,存在于静态区,属于整个类,属于类的所有对象,而不属于某个对象,当我们用sizeof()
求某个类的成员或者类类型的大小的时候,不会包括静态成员变量。例如:
class A
{
public:
A()
{
count++;
}
A(const A& aa)
{
count++;
}
private:
static int count;
};
int main()
{
cout << sizeof(A) << endl;
}
输出结果为1。
问:那么静态成员变量是否在初始化列表中进行初始化的呢?
答:不是,因为只有具体的对象在初始化的时候才会在初始化列表进行初始化。
除了成员变量可以是静态的,成员函数也可以是静态的,成员函数最为重要的特征是:没有this指针。
我们在类外访问静态成员函数有两种方式:
class A
{
public:
static void Func()
{
}
};
int main()
{
A a1;
a1.Func();//使用类的实例化成员来进行调用静态成员函数
A::Func();//使用类的类名来调用静态成员函数
return 0;
}
上面两种调用方式无论是哪一种,都只是为了突破类域。
【问题】
C++11支持非静态成员变量在声明时进行初始化赋值,但是要注意这里不是初始化,这里是给声明的成员变量缺省值。
注意:静态成员变量无法赋缺省值,只能在类外进行定义并初始化,为什么?因为此处只是声明,并不是真正的定义,初始化列表只有在显式创建对象的时候才会用到。
下面的代码就是错误的:
class A
{
private:
int _a = 1;
static int _ref = 10;//此处就是错误的,因为静态成员变量只能在类外进行定义并初始化
};
//下面才是正确的
class A
{
private:
int _a = 1;
static int _ref = 1;//此处就是错误的,因为静态成员变量只能在类外进行定义并初始化
};
int A::_ref = 10;
友元分为:友元函数和友元类
友元提供了一种突破封装的方式,有时提供了便利。但是友元会增加耦合度,破坏了封装,所以友元不宜多用。
友元函数可以直接访问类的私有成员,它是定义在类外部的普通函数,不属于任何类,但需要在类的内部声明,声明时需要加friend关键字。
友元函数的经典使用:
class Date
{
friend ostream& operator<<(ostream& out, const Date& d);//在operator<<函数内可以在类外访问Date类的成员变量
public:
Date(int year,int month,int day)
{
_year = year;
_month = month;
_day = day;
}
private:
int _year;
int _month;
int _day;
};
ostream& operator<<(ostream& out,const Date& d)
{
out << d._year << "-" << d._month << "-" << d._day << endl;
return out;
}
int main()
{
Date d1(2022, 5, 20);
cout << d1;
return 0;
}
说明:
下面是一个例子:
class Date;
//问:此处为什么要加一个前置声明?
//答:因为在Time里面对Print友元函数的声明中,向前找是找不到Date类的声明或者定义的,所以必须在此处声明Date是一个类的名字,关于具体的Date类的定义可以去后面找
class Time
{
friend void Print(const Date& d, const Time& t);//Print是Time类的友元函数,在Print函数内可以访问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
{
friend void Print(const Date& d, const Time& t);//Print是Date类的友元函数,在Print函数内可以访问Date类的成员变量
public:
Date(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}
private:
int _year;
int _month;
int _day;
Time _t;
};
void Print(const Date& d,const Time& t)
{
cout << d._year << "-" << d._month << "-" << d._day << "-";
cout << t._hour << "-" << t._minute << "-" << t._second << endl;
}
int main()
{
Date d1(2022, 5, 20);
Time t1;
Print(d1, t1);
return 0;
}
注意:下面的这种友元函数的使用方法是错误的,且目前C++没有这种语法来实现:
class Time
{
friend void Date::Print();
public:
Time(int hour = 0, int minute = 0, int second = 0)
{
_hour = hour;
_minute = minute;
_second = second;
}
int _hour;
int _minute;
int _second;
};
class Date
{
public:
Date(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}
void Print()
{
cout << _year << "-" << _month << "-" << _day << "-";
cout << _t._hour << "-" << _t._minute << "-" << _t._second;
}
private:
int _year;
int _month;
int _day;
Time _t;
};
int main()
{
Date d1(2022, 5, 20);
d1.Print();
return 0;
}
如果我们想在Date类中访问Time类中的成员变量,只有一种方法,就是将Date声明为Time的友元类,出吃之外没有其它的方法,即C++不支持将某个类中的成员函数声明为某个类的友元函数。
友元类的所有成员函数都可以是另一个类的友元函数,都可以访问另一个类中的非公有成员。
友元类的经典使用:
class Time
{
friend class Date;//Date是Time的友元类,可以在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, int month, int day)
{
_year = year;
_month = month;
_day = day;
}
void Print()
{
cout << _year << "-" << _month << "-" << _day << "-";
cout << _t._hour << "-" << _t._minute << "-" << _t._second << endl;
}
private:
int _year;
int _month;
int _day;
Time _t;
};
int main()
{
Date d1(2022, 5, 20);
d1.Print();
return 0;
}
比如上述Time类和Date类,在Time类中声明Date类为其友元类,那么可以在Date类中直接访问Time 类的私有成员变量,但想在Time类中访问Date类中私有的成员变量则不行。
如果B是A的友元,C是B的友元,则不能说明C时A的友元。
class A
{
friend class B;
};
class B
{
friend class C;
};
class C
{
};
此时在C中可以访问到B的成员变量和成员函数,但是不能在C中访问到A的成员变量和成员函数。
概念:如果一个类定义在另一个类的内部,这个内部类就叫做内部类。注意此时这个内部类是一个独立的类,它不属于外部类,更不能通过外部类的对象去调用内部类。外部类对内部类没有任何优越的访问权限。
注意:内部类就是外部类的友元类。注意友元类的定义,内部类可以通过外部类的对象参数来访问外部类中 的所有成员。但是外部类不是内部类的友元。
特性:
class A
{
public:
class B
{
}
}
int main()
{
A::B b1;//B是A的内部类,定义B类型的变量的时候要在B的前面加上外部类限定符即A
return 0;
}
class Sum
{
public:
Sum()
{
_ret+=_i;
_i++;
}
static int GetRet()
{
return _ret;
}
private:
static int _ret;
static int _i;
};
int Sum::_i = 1;
int Sum::_ret = 0;
class Solution {
public:
int Sum_Solution(int n) {
Sum a[n];
return Sum::GetRet();
}
};
使用内部类:
class Solution {
public:
int Sum_Solution(int n) {
Sum a[n];
return _ret;
}
class Sum
{
public:
Sum()
{
_ret += _i;
_i++;
}
};
private:
static int _ret;
static int _i;
};
int Solution::_i = 1;
int Solution::_ret = 0;
代码:
#include<iostream>
using namespace std;
bool IsLeapYear(int year)
{
if((year % 4 == 0 && year % 100 != 0)|| year % 400 == 0)
{
return true;
}
else
{
return false;
}
}
int main()
{
int SumMonthDay[13] = {0,31,59,90,120,151,181,212,243,273,304,334,365};//存储前n-1个月的天数和
int year = 0;
int month = 0;
int day = 0;
int ret = 0;
cin >> year >> month >> day;
ret = SumMonthDay[month - 1] + day;//前n - 1个月的和加上当前月的天数
if(month > 2 && IsLeapYear(year))//判断是否是闰年,如果是闰年并且前面跨过了2月就加一天
{
ret += 1;
}
cout << ret;
return 0;
}
代码:
#include<iostream>
using namespace std;
bool IsLeapYear(int year)
{
if((year % 4 == 0 && year % 100 != 0)|| year % 400 == 0)
{
return true;
}
else
{
return false;
}
}
int main()
{
//都按照平年来计算
int SumMonthDay[13] = {0,31,59,90,120,151,181,212,243,273,304,334,365};//存储前n-1个月的天数和
int year = 0;
int day = 0;
cin >> year >> day;
for(int i = 0;i < 13; i++)
{
if(day <= SumMonthDay[i])
{
if(i > 2 && IsLeapYear(year))//判断是否超过2月并判断是否是闰年
{
day -= 1; //如果是闰年就减一天变成平年和一样的算法
}
day -= SumMonthDay[i - 1];//减去跨过的天数就是剩余当前月的天数
printf("%d-%02d-%02d",year, i, day);
break;
}
}
return 0;
}
代码:
#include<iostream>
using namespace std;
int GetMonthDay(int year,int month)
{
int MonthDay[13] = {0,31,28,31,30,31,30,31,31,30,31,30,31};//存储每个月对应的天数
if(month == 2 && (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0))//判断是否是2月和是闰年
return 29;
return MonthDay[month];
}
int main()
{
int num = 0;
cin >> num;
int year = 0;
int month = 0;
int day = 0;
int x = 0;//存储要加的天数
for(int i = 0; i < num; i++)
{
cin >> year >> month >> day >> x;
day += x;
while(day > GetMonthDay(year, month))
{
day -= GetMonthDay(year, month);
month++;
if(month == 13)
{
month = 1;
year++;
}
}
printf("%4d-%02d-%02d\n",year, month, day);
}
return 0;
}
C++是基于面向对象的程序,面向对象有三大特性即:封装、继承、多态。
C++通过类,将一个对象的属性与行为结合在一起,使其更符合人们对于一件事物的认知,将属于该对象的 所有东西打包在一起;通过访问限定符选择性的将其部分功能开放出来与其他对象进行交互,而对于对象内部的一些实现细节,外部用户不需要知道,知道了有些情况下也没用,反而增加了使用或者维护的难度,让整个事情复杂化。
可以看出面向对象其实是在模拟抽象映射现实世界。
我的一位教授给了我们一些考试练习题,其中一个问题类似于下面(伪代码): a.setColor(blue); b.setColor(red); a = b; b.setColor(purple); b
我似乎经常使用这个测试 if( object && object !== "null" && object !== "undefined" ){ doSomething(); } 在对象上,我
C# Object/object 是值类型还是引用类型? 我检查过它们可以保留引用,但是这个引用不能用于更改对象。 using System; class MyClass { public s
我在通过 AJAX 发送 json 时遇到问题。 var data = [{"name": "Will", "surname": "Smith", "age": "40"},{"name": "Wil
当我尝试访问我的 View 中的对象 {{result}} 时(我从 Express js 服务器发送该对象),它只显示 [object][object]有谁知道如何获取 JSON 格式的值吗? 这是
我有不同类型的数据(可能是字符串、整数......)。这是一个简单的例子: public static void main(String[] args) { before("one"); }
嗨,我是 json 和 javascript 的新手。 我在这个网站找到了使用json数据作为表格的方法。 我很好奇为什么当我尝试使用 json 数据作为表时,我得到 [Object,Object]
已关闭。此问题需要 debugging details 。目前不接受答案。 编辑问题以包含 desired behavior, a specific problem or error, and the
我听别人说 null == object 比 object == null check 例如: void m1(Object obj ) { if(null == obj) // Is thi
Match 对象 提供了对正则表达式匹配的只读属性的访问。 说明 Match 对象只能通过 RegExp 对象的 Execute 方法来创建,该方法实际上返回了 Match 对象的集合。所有的
Class 对象 使用 Class 语句创建的对象。提供了对类的各种事件的访问。 说明 不允许显式地将一个变量声明为 Class 类型。在 VBScript 的上下文中,“类对象”一词指的是用
Folder 对象 提供对文件夹所有属性的访问。 说明 以下代码举例说明如何获得 Folder 对象并查看它的属性: Function ShowDateCreated(f
File 对象 提供对文件的所有属性的访问。 说明 以下代码举例说明如何获得一个 File 对象并查看它的属性: Function ShowDateCreated(fil
Drive 对象 提供对磁盘驱动器或网络共享的属性的访问。 说明 以下代码举例说明如何使用 Drive 对象访问驱动器的属性: Function ShowFreeSpac
FileSystemObject 对象 提供对计算机文件系统的访问。 说明 以下代码举例说明如何使用 FileSystemObject 对象返回一个 TextStream 对象,此对象可以被读
我是 javascript OOP 的新手,我认为这是一个相对基本的问题,但我无法通过搜索网络找到任何帮助。我是否遗漏了什么,或者我只是以错误的方式解决了这个问题? 这是我的示例代码: functio
我可以很容易地创造出很多不同的对象。例如像这样: var myObject = { myFunction: function () { return ""; } };
function Person(fname, lname) { this.fname = fname, this.lname = lname, this.getName = function()
任何人都可以向我解释为什么下面的代码给出 (object, Object) 吗? (console.log(dope) 给出了它应该的内容,但在 JSON.stringify 和 JSON.parse
我正在尝试完成散点图 exercise来自免费代码营。然而,我现在只自己学习了 d3 几个小时,在遵循 lynda.com 的教程后,我一直在尝试确定如何在工具提示中显示特定数据。 This code
我是一名优秀的程序员,十分优秀!