C++基础——类与对象(上)

面向对象四大特征:

特征	                  说明	                                                   类比
抽象	   抽出具体事物的普遍性的本质	     分门别类:鸟类、哺乳类、鱼类
封装    把数据与处理(函数)包在一起            通信录(增加、删除)
继承    数据与处理(函数)的传承	             财富与绝技、混血儿(肤色/头发、 两种语言
多态    同一个事物(函数)的多种形态            手机键盘数字与字母、 电脑键盘功能键

类的定义:

与C/C++中的struct类似

class 类名{
    成员变量和成员函数的声明;
};
PS:class定义最后要加“;”。

构成:

构成							作用
数据成员/成员变量/属性		对象内部数据和状态,只能在类定义中声明,可以在成员函数中直接调用。
成员函数/方法				对象相关的操作,可以在类内实现或类外实现。

作用域运算符:

::——函数归属。

访问限定符:

限定符		作用
private[默认]	私有
public		公开
protected	保护
时间中,成员变量多数情况使用private或者protected;成员函数多数情况下使用public。通常。通过成员函数改变对象的成员变量。

声明与实现分离

头文件(,h文件)——声明

即将类的声明放到头文件中。

方式:

#pragma once
#ifnde...#endif
上面任选其一即可。
作用——防止头文件二次编译。

源文件(.cpp文件)——实现

即将类的实现放到源文件中。

引用头文件:

#include <>(标准库函数)
#include ""(自定义/第三方函数)
上面任选其一即可。

class与struct的区别:

1.默认的访问控制不同(主要)

struct是public(共有——类外可以调用)
class是private(私有——类外不可调用)

2.初始化不同

struct可以使用花括号内的初始值列表{...}初始化,class不可以(C++98不可以,C++11可以)。

PS:

成员变量默认初始化为随机值(主要影响指针)。

C++的struct可以有成员函数,而C不可以。
C++的struct可以使用访问控制关键字(public private protected),而C不可以。

对象的创建:

1.直接定义:

类作为类型定义变量——栈上创建。

类名 对象1;// 调用默认构造函数
类名 对象2 = 对象1;// 调用复制构造函数
类名 对象3(对象1);// 调用复制构造函数

2.动态创建:

堆上创建。

类名* 对象指针 = new 类名;// 调用默认构造函数
delete 对象指针;


int* p = new int[10];
delete p;// 只释放p[0]
delete [] p;// 释放全部数组

基本类型的初始化新增语法:

int a(0);// 等价 int a = 0;
const float b(1.0);// 等价 const float b = 1.0;

注意:

空结构体与空类的大小(sizeof)为1,主要在于初始化/实例化时,编译器给变量/对象分配内存(地址),内存最小单位为1个字节。通常,sizeof(类型) == sizeof(变量)。
C++除了特殊情况,很少直接使用malloc()/free()申请释放内存,取而代之的是new/delete。

this指针

作用域——类的内部。

特点:

1.类的一个自动生成,自动隐藏的私有成员。

2.每个对象仅有一个this指针。

3.当一个对象被创建时,this指针就存放了指向对象数据的首地址。

4.不是对象本身的一部分,不会影响sizeof(对象)的结果。

5.如果成员函数形参与成员变量同名,使用this->作为成员变量的前缀来区分。

构造函数

语法:

类名(参数){
  函数体;
};
在对象被创建时自动执行;

构造函数的函数名与类名相同;

没有返回值类型,也没有返回值;

可以有多个构造函数。

调用时机

1.对象直接定义创建(构造函数不能被显式调用);

2.new动态创建。

默认构造函数

类中没有显式的定义任何构造函数,编译器就会自动为该类生成默认构造函数。

构造函数的3个作用

1.给创建的对象建立一个标识符;

2.为对象数据成员开辟没存空间;

3.完成对象数据成员的初始化。

初始化列表

类名(参数):成员变量(参数){
函数体;
};

作用

初始化非静态成员变量。

说明

从概念上来说,构造函数的执行可以分成两个阶段:初始化阶段和计算阶段(函数体中的赋值)。初始化阶段先于计算阶段。

必须使用初始化列表的情况

1.常量成员,因为常量只能初始化不能赋值,所以必须放在初始化列表里面。
2.引用类型,引用必须在定义的时候初始化,并且不能重新赋值,所以也要写在初始化列表里面。
3.没有默认构造函数的类型,因为使用初始化列表可以不必调用默认构造函数来初始化,而是直接调用拷贝构造函数初始化。

成员变量初始化顺序

成员变量在使用初始化列表初始化时,与构造函数中初始化成员列表的顺序无关,只与定义成员变量的顺序有关。

C++的函数可以增加默认参数。

写法:
默认参数必须写在函数声明中,不能写在函数实现的参数列表中中。
默认参数必须写在所有非默认参数的后面。
默认参数可以写任意多个。
使用:
默认参数可以不用传递值,此时,使用默认值。
默认参数可以传值,此时,使用实参值。
代码例子

class Complex{
public:
	Complex():real(0),imag(0){
		//this->real = 0;
		//this->imag = 0;
	}
	Complex(float real,float imag):real(real),imag(imag){
		//this->real = real;
		//this->imag = imag;
	}
	~Complex(){

	}	
	void print();
	Complex add(const Complex& other);
	Complex subtract(const Complex& other);

	Complex operator+(const Complex& other)const;
	Complex operator-(const Complex& other)const;
	friend ostream& operator<<(ostream& out,const Complex& c);
private:
	float real;
	float imag;
};

析构函数

~类名(){
  函数体
}

语法

析构函数的函数名与类名相同;

函数名前必须有一个~;

没有参数;

没有返回值类型和返回值;

只能有一个析构函数。

调用时机

1.对象离开作用域;

2.delete函数调用时。

默认析构函数

类中没有显式的定义析构函数,编译器就会自动为该类型生成默认析构函数。

作用

释放对象所申请占有的资源。

引用(别名)

声明

const 类型名& 对象名/类型名& 对象名

使用

与对象变量,基本类型变量一样。

作用

取代指针

引用于指针的区别

引用与指针的区别
指针指向一块内存,它的内容是所指内存的地址;引用是某块内存的别名。
引用只能在定义时被初始化一次,之后不可变;指针可变;
引用不能为空,指针可以为空;
引用使用时无需解引用*,指针需要解引用(*p);
sizeof()引用得到的是所指向的变量/对象的大小,而sizeof 指针得到的是指针本身的大小;
引用通常用于两种情形:成员变量和函数的参数列表。

拷贝/复制构造函数

语法(3种形式)

类名(类名& 形参){ 
  函数体
}
类名(const 类名& 形参){
  函数体
}
类名(const 类名 形参){
  函数体std:swap();
}

调用时机

一个对象作为函数参数,以值传递的方式传入函数体
一个对象作为函数返回值,以值从函数返回
一个对象用于给另外一个对象进行初始化(赋值初始化)

代码示例

Bill::Bill(const Bill& b):name(NULL),price(b.price),count(b.count),discount(b.discount){
     name = new char[strlen(b.name)+1];
     strcpy(name,b.name);
}

默认拷贝构造函数

本质:内存拷贝
作用:复制一个已经存在的对象

猜你喜欢

转载自blog.csdn.net/lingfeng2019/article/details/75314858