类的用户是程序员,而不是最终的用户。
定义在类内部的函数都是隐式的内联函数。
类中成员变量的声明顺序,决定了成员变量的初始化顺序。
成员函数可以定义在类内部也可以定义在类外部
#include<bits/stdc++.h>
using namespace std;
struct temple{
void print(string x);
string num,name;
};
void temple::print(string x){cout<<x<<endl;}
int main(){
temple a;
a.num="这是一个struct类";
a.print(a.num);
return 0;
}
//在类的外部定义函数,必须包含它所属的类名
const 函数
在函数括号后加一个const说明这个函数是一个只读函数,不会修改任何数据。是一个常量函数。this是一个常量指针,总是指向这个对象,任何对类成员的直接访问都被看做this的隐式引用。
默认情况下,this的类型是指向 类类型的非常量版本的 常量指针。
声明const常量函数的作用是将这个指针转换为常量指针。
返回一个函数
#include<bits/stdc++.h>
using namespace std;
struct Node{
int a,b;
Node re(){ return *this;}//返回的是一个引用,建立一个临时变量,然后拷贝给目标对象,返回的是右值
}a;
int main(){
a.a=1;
(a.re()).a=2;//报错:将临时变量作为一个左值
cout<<a.a<<endl;
}
构造函数
struct Node{
Node()=default;//我们不仅需要别的构造函数,同时也需要默认的构造函数。default的意思就是默认的合成构造函数
Node(int x1,string s):tool1(x1),tool2(s),sum(3){};
int tool1,sum;
string tool2;
};
class 和 struct的区别。
如果使用struct,在第一个访问说明符出现之前的成员是public的,相反,如果使用class,在第一个访问说明符之前出现的成员是private的。
友元
既然类有私有成员变量,那么如果访问类的私有成员呢?
方法是设立友元、
class Node{
friend void print(Node x);这只是权限说明,并不声明.如果希望类的用户调用某个友元函数,还要再声明一下。
int pre;
public :
Node(int x):pre(x),mid(x),las(mid){};
int mid;
private:
int las;
};
void print(Node a){
cout<<a.las;
}
int main(){
Node a=Node(444);
print(a);
}
mutable
#include<bits/stdc++.h>
using namespace std;
class Node{
public :
void member()const;
void prin(){ cout<<counts;}//mutable,如果希望某个成员变量能够在const函数中进行修改,那么可以在这个变量定义之前加上mutable
private: mutable size_t counts;
};
void Node::member() const { counts++; }
int main(){
Node a;a.member();a.member();
a.prin();
return 0;
}
前向声明
#include<bits/stdc++.h>
using namespace std;
class Node;//前向声明:先声明后定义的类型
Node * p;//在定义之前是一种不完全类型。只能在非常有限的情况中使用。引用或者指针,
class Node{int a,b;};//定义
int main(){}
令成员函数作为友元
#include<string>
#include<iostream>
using namespace std;
//令成员函数作为友元
//首先定声明友元函数,但是不能声明
//然后声明友元
//然后定义友元函数
class B{
public :
void clear();
};
class A{
friend void B::clear();
public :
void prin(){
cout<<a<<endl;
}
private:
int a;
};
void B::clear(){
A tem;
tem.a=5;
}
int main(){
A a;
B b;
b.clear();
}
友元函数作用域:
友元函数声明为友元 和声明为函数 是不一样的,friend只是声明权限。如下:
#include<bits/stdc++.h>
using namespace std;
struct Node{
friend void f();//定义一个友元函数
// Node(){f();}//错误f没有被声明
void g();
void h();
};
//void Node::g(){f(); }//错误:f仍旧没有被声明
void f(){}
void Node::h(){f();}//正确
int main(){
return 0;
}
名字查找:
- 在普桶程序中找声明语句
- 首选在名字所在的块中查找,如果这个块(仅仅考虑使用之前出现的声明)没有找到,那么在外层作用域中找,如果还没有找到,就报错
- 成员函数中
- 首选在名字所在的函数中查找,如果这个函数(仅仅考虑使用之前出现的声明)没有找到, 则在类中继续查找。如果还没有找到,就在成员函数定义之前的作用域中继续查找。类作用域之后,也在类作用域之外进行查找
委托构造函数
顾名思义:将自己的构造任务委托给别人
class Node{
Node(int x,int y):a(x),b(x){};
Node():Node(0,0){};
public :
private:
int a,b;
};
隐式类类型转换
#include<bits/stdc++.h>
using namespace std;
//隐式类类型转换
class Node{
int a;
public :
void deal(Node a){};
Node(int a):a(a){}
Node()=default;
};
int main(){
Node a;
a.deal(5);//这里本来期望收到一个Node的参数,但是收到了一个int,发生了隐式类类型转换
return 0;
}
explicit
“可以用 单个形参来调用 的构造函数定义了从 形参类型 到 该类类型 的一个隐式转换。”
在隐式类类型转换中并不是只能有一个参数可以有多个参数,但是这些参数都是默认实参的。
excplict 抑制了隐式类类型转换
#include<bits/stdc++.h>
using namespace std;
//隐式类类型转换
class Node{
int a;
public :
void deal(Node a){};
explicit Node(int a):a(a){}
Node()=default;
};
int main(){
Node a;
a.deal(5);//报错,explicit抑制了隐式类类型转换
return 0;
}
聚合类:
聚合定义为:
数组、没有以下内容的类、结构和联合:
构造函数、私有或受保护的成员、基类、虚函数
#include<bits/stdc++.h>
using namespace std;
//隐式类类型转换
class Node{
public:
int a;
int b;
};
int main(){
Node a={1,2};
return 0;
}
初探字面值常量类
数据成员必须是字面值类型
类必须至少包含一个constexpr函数,
如果类内有初始值,则必须是constexpr,如果某种成员有自己的类类型,则这个* 成员必须有自己的constexpr构造函数。
必须使用析构函数的默认定义,该成员负责销毁类的对象。
constexpr函数:所有形参和返回值都是字面值类型,有且只有一个return类型。
constexpr类的构造函数可以=default,构造函数体一般是空的,
静态成员static。
必须再类的外部进行初始化。
#include<bits/stdc++.h>
using namespace std;
class Account{
public:
void calculate(){
amount += amount * interestRate;
}
static double rate(){
return interestRate;
}
static void rate(double newrate);
private:
std::string owner;
double amount;
static double interestRate;
static double initRate();
};
double Account::interestRate=0;//必须在类的外部定义和初始化每个成员。
void Account::rate(double newrate){
interestRate=newrate;
}
int main(){
double r=Account::rate();
return 0;
}
如果成员变量是字面值常量类型的constexpr,就可以它提供const整数类型的类内初始值,不过要求静态成员必须是字面值常量类
#include<bits/stdc++.h>
using namespace std;
class Account{
public :
private:
static constexpr int period=30;//只有声明没有定义,可以用作数值。但是引用等需要在类外定义
};
int main(){
}
#include<bits/stdc++.h>
using namespace std;
class Account{
public :
private:
static constexpr int period=30;//
};
constexpr int Account::period;//初始值再类内的定义
int main(){
}
static成员可以用作默认形参,也可以是不完全类型。
#include<bits/stdc++.h>
using namespace std;
struct Bar{
public :
void change(Bar = bar){};//静态成员可以用作默认形参
private:
static Bar bar;//静态成员可以是不完全类型(即没有被完整定义的类型)
Bar* bbar;
// Bar bbbar;//报错,数据类型不能是不完全类型
};
int main(){
}