目录
new关键字
int * p = new int(10)//开辟一个空间,里面数据是10
//并且返回键这个空间的地址
int * arr = new int[10]//开辟十个空间
//并且返回这个数组的首地址
delete p;释放一个空间
delete [] arr;//释放一个数组
引用
作用:起别名
语法:数据变量 &别名 = 原名
int a = 10;
int &b = a;//a和b都是a的空间
//a的别名是b
//数据变量得一致
引用的注意事项
- 引用必须初始化
- 引用在初始化后,不可以改变(a的别名是b,不能再使得b的别名)
int a = 3;
int b = 4;
int& c = a;
int& c = b;//不能再使c为其他人的别名,不能多次初始化
printf("%d", c);
//运行错误
引用做函数参数
作用:函数传参时,可以利用引用的技术让形参修饰实参
优点:可以简化指针修改实参
void myswap(int& a, int& b)
{
int temp = a;
a = b;
b = temp;
}
int main()
{
int a = 10;
int b = 20;
myswap(a, b);
cout << "a=" << a << "b=" << b << endl;
return 0;
}
引用作函数返回值
int& test()
{
static int a = 3;
return a;
}
int main()
{
int& ref = test();
cout << "ref=" << ref << endl;
return 0;
}
且函数的调用可以作为左值
test() = 100;//意思就是a = 100
引用的本质
本质矩阵c++内部实现是一个指针常量
常量引用
作用:常量引用主要用来修饰形参,防止误操作
在函数形参列表中,可以加const来修饰形参,防止形参改变实参
void showValue(const int& val)
{
val = 1000;//报错,无法更改
cout << "val=" << val << endl;
}
int main()
{
int a = 100;
showValue(a);
return 0;
}
函数提高
函数默认参数(缺省函数)
c语言用法
int func(int a, int b, int c)
{
return a + b + c;
}
int main()
{
cout << func(10, 20, 30) << endl;
system("pause");
}
c++
(如果我们自己传入数据,就用自己的数据,如果没有,就用默认值)
全缺省
int func(int a=10, int b=20, int c=30)
{
return a + b + c;
}
int main()
{
cout << func() << endl;
system("pause");
}
半缺省
(如果半缺省函数某个位置有了默认参数,则这个位置的右边都必须有默认值)
int func(int a, int b=20, int c=30)
{
return a + b + c;
}
int main()
{
cout << func(10) << endl;
system("pause");
}
注意
如果函数声明有默认参数,函数实现就不能有默认参数
int func(int a=10, int b=20, int c=30);
int func(int a=10, int b=20, int c=30)//报错,不能在函数二次实现默认值
{
return a + b + c;
}
函数占位参数
c++函数的形参列表里可以有占位参数,用来做占位,调用函数时必须填补该位置。
语法:返回值类型 函数名(数据类型){}
void func(int a,int)//第二个参数为占位参数,必须要传入一个参数才能使用函数
{
cout << "this is func" << endl;
}
int main()
{
func(10,1);
system("pause");
}
函数重载
作用:函数名可以相同,提高复用性
满足条件:
- 同一个作用域下
- 函数名称相同
- 函数参数类型不同或者参数类型个数不同或者参数类型顺序不同
注意事项
引用作为重载的条件
void func(int &a)//不调用这个,因为int& a = 10不合法。
{
cout << "func(int &a)调用" << endl;
}
void func(const int& a)//调用这个,因为const int& a =10合法 (因为const创建了一个临时的空间)
{
cout << "func(const int &a)调用" << endl;
}
int main()
{
func(10);
system("pause");
}
类和对象
c++面向对象的三大特性为:封装,继承,多态
c++认为万事万物皆为对象.
封装
意义:(1)将属性和行为作为一个整体,表示生活中的事物
(2)将属性和行为加以权限控制
class ------- 类-----跟c语言struct类似----但里面能包含函数
class circle
{
public://公共权限
double calculatecircle()
{
return 2 * 3.14 * m_r;//行为
}
int m_r;//属性
private://私有权限
};
int main()
{
circle c1;//创建具体的圆(对象)
//实例化----通过一个类创建一个对象
c1.m_r = 10;
cout << c1.calculatecircle() << endl;
system("pause");
}
访问权限
公共权限 public:成员类内可以访问,类外也可以访问
保护权限 protected:成员类内可以访问,类外不可以访问
私有权限 private:成员类内可以访问,类外不可以访问
class Person
{
public://公共权限
string m_Name;
void func()
{
m_Name = "张三";
m_Car = "拖拉机";
m_passwords = 123456;
}
protected:
string m_Car;
private://私有权限
int m_passwords;
};
int main()
{
Person p1;
p1.m_Name = "李四";
p1.m_Car = "奔驰";//报错,因为m_Car为保护权限,类外无法访问
//私有类外也无法访问
p1.func();//可以访问
system("pause");
}
struct 和 class 的区别
在c++中struct和class唯一的区别就在于默认的访问权限不同
struct默认权限是 public
class默认权限是private
封装设计案例
class Person
{
public://公共权限
//设置姓名
void set_Name(string name)
{
m_Name = name;
}
//获取姓名
string get_Name()
{
return m_Name;
}
int get_Age()
{
m_Age = 0;
return m_Age;
}
void set_Lover(string lover)
{
m_lover = lover;
}
private://私有权限
//姓名 可读可写
string m_Name;
//年龄 只读
int m_Age;
//情人
string m_lover;
};
int main()
{
Person p;
p.set_Name("张三");
cout << "姓名为:" << p.get_Name() << endl;
cout << "年龄为:" << p.get_Age() << endl;
system("pause");
}
对象的初始化和清理(构造与析构函数)
-
一个对象或者变量没有初始状态,对其使用后果是未知。
-
使用完一个对象或变量,没有及时清理,也会造成一定安全问题。
构造函数
主要作用在于创建对象时为对象的成员赋值(初始化),构造函数由编译器自动调用,无需手动调节。
如果我们不提供构造函数,编译器会提供构造函数是空实现,如果我们提供就用我们的。
语法:类名(){}
- 没有返回值
- 函数名称与类名相同
- 可以有参数,可以发送重载
- 程序在调试对象时候会自动调用构造,只会调用一次
析构函数
主要作用在于对象销毁前会自动调用构造,执行一些清理工作。
如果我们不提供析构函数,编译器会提供构造函数是空实现,如果我们提供就用我们的。
语法:~类名(){}
- 没有返回值
- 函数名称与类名相同,名称前加~
- 不可以有参数,不可以发送重载
- 程序在销毁前会自动调用析构,只会调用一次
class Person
{
public:
Person()
{
cout << "构造函数调用" << endl;
}
~Person()
{
cout << "析构函数调用" << endl;
}
};
int main()
{
Person p;//创建的时候,构造调用,对象销毁的时候(这个对象在全局变量中,所以只有程序结束才会销毁对象),析构调用
}
构造函数的分类及调用
- 有参无参的调用
class Person
{
public:
Person()
{
cout << "Person的无参构造函数调用" << endl;
}
Person(int a)
{
cout << "Person的有参构造函数调用" << endl;
}
};
int main()
{
Person p;
}
以上打印无参构造函数调用
class Person
{
public:
Person()
{
cout << "Person的无参构造函数调用" << endl;
}
Person(int a)
{
cout << "Person的有参构造函数调用" << endl;
}
};
int main()
{
Person p(1);
}
以上打印有参构造函数调用
- 拷贝构造
将传入的人身上的所有属性,拷贝到我身上
class Person
{
public:
Person(int a)
{
age = a;
cout << "Person的有参构造函数调用" << endl;
}
Person(const Person& p)//拷贝构造
{
age = p.age;
}
int age;
};
int main()
{
Person p(10);
Person p2(p);//拷贝构造
cout << "p2的年龄为:" << p2.age << endl;
}
括号法
Person p1;
Person p2(10);//有参构造
Person p3(p2)//拷贝构造
显示法
Person p1;
Person p2 = Person(10);//有参构造
Person p3 = person(p2)//拷贝构造
隐式转换法
Person p4 =10; //相当于Person p4 = Person (10);
Person p5 = p4;//拷贝
拷贝函数的值传递
void dowork(Person p)//传参过来类似于Person p = p(隐式转换法)
{
}
int main()
{
Person p;
dowork(p);
return 0'
}
值方式返回局部对象
Person dowork()
{
Person p1;
return (p1);
}
int main()
{
Person p = dowork();
return 0;
}
构造函数调用规则
- 如果用户定义有参构造函数,c++不再提供默认无参函数,但是会提供默认拷贝构造
- 如果用户定义拷贝构造函数,c++不会再提供其他构造函数
只要创建一个类,编译器就会提供三个函数
class Person
{
public:
Person()
{
cout << "默认构造函数调用" << endl;
}
Person(int age)
{
cout << "创建构造函数调用" << endl;
m_age = age;
}
Person(const Person& p)
{
cout << "拷贝函数调用" << endl;
m_age = p.m_age;
}
~Person()
{
cout << "默认析构函数调用" << endl;
}
int m_age;
};
void test01()
{
Person p;
p.m_age = 19;
Person p2(p);
cout << "p2年龄为:" << p2.m_age << endl;
}
int main()
{
test01();
return 0;
}
深拷贝与浅拷贝
- 浅拷贝:浅拷贝是会将对象的每个属性进行依次复制。就是编译器默认实现的操作
- 深拷贝:深拷贝后的对象与原来的对象是完全隔离的,互不影响,对一个对象的修改并不会影响另一个对象。
注意事项
- 调用默认构造函数的时候,不要加()。
Person p1();//会当成函数声明
初始化列表
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 test()
{
person p(10,20,30);
cout << "m_A=" << p.m_A << endl;
cout << "m_B=" << p.m_B << endl;
cout << "m_C=" << p.m_C << endl;
}
int main()
{
test();
return 0;
}
分割线,下面全是水
类对象作为类成员
构造时候先构造类对象,再构造自身
析构顺序与构造相反
const修饰成员函数
常函数:
- 成员函数后加const我们称这个函数为常函数
- 常函数内不可修改成员属性
- 成员属性声明时加关键字mutable,在常函数内依然可以更该
常对象:
- 声明对象前加const称该对象为常对象
- 常对象只能调用常函数
友元–friend
生活中你的家有课厅(public),有你的卧室(private)
客厅所有人都可以进去,但是你的卧室是私有的,也就是说只有你能进去
但是,你也可以允许你的好闺蜜好基友进去。
在程序里,有些私有属性 也想让类外特殊的一些函数或者类进行访问,就需要用到友元的技术
友元的关键字为 friend
全局函数做友元
class Buiding
{
public:
Buiding()
{
m_sittingRoom = "客厅";
m_BedRoom = "卧室";
}
//告诉编译器goodGay全局函数,是Buiding类的好朋友,可以访问类中的私有内容
friend void goodGay(Buiding& buiding);//令goodGay函数可以访问Buiding类的私有属性
string m_sittingRoom;//客厅
private:
string m_BedRoom;//卧室
};
//全局函数访问
void goodGay(Buiding& buiding)
{
cout << "好基友的全局函数正在访问 : " << buiding.m_sittingRoom << endl;
cout << "好基友的全局函数正在访问 : " << buiding.m_BedRoom << endl;
}
int main()
{
Buiding buiding;
goodGay(buiding);
return 0;
}
类做友元
class Buiding
{
friend class GoodGay;
public:
Buiding()
{
m_sittingRoom = "客厅";
m_BedRoom = "卧室";
}
string m_sittingRoom;//客厅
private:
string m_BedRoom;//卧室
};
class GoodGay
{
public:
GoodGay();
Buiding* buiding;
void visit();//参观函数 访问Buiding中的属性
};
GoodGay::GoodGay()
{
buiding = new Buiding;
}
void GoodGay::visit()
{
cout << "好基友类正在访问" << buiding->m_sittingRoom << endl;
cout << "好基友类正在访问" << buiding->m_BedRoom << endl;
}
int main()
{
GoodGay bro;
bro.visit();
return 0;
}