C++基础

C++核心:面向对象

一维数组定义:

int arr[3] 初始化必须有长度

常量指针

const 修饰指针

int a = 10;

int b = 20;

const int *p = &a;

p = &b;

常量指针特点:指针的指向可以修改,但是指针指向的值不可以改

C++基础_第1张图片

指针常量

const修饰常量

int a = 10;

int * const p = &a;

指针常量特点:指针的指向不可以改,指针指向的值可以改

*p = 20;

C++基础_第2张图片

既修饰指针,又修饰长量

const int* const p = &a;

特点:指针的指向和指针指向的值都不可以改

内存的分区模型

c++程序在执行时,将内存大方向划分为4个区域

代码区:存放函数体的二进制代码,由操作系统进行管理

全局区:存放全局变量静态变量以及常量(main函数外面的:int a; static int a; const int a)

栈区:由编译器自动分配释放,存放函数的参数值,局部变量等

堆区:由程序员分配和释放,若程序员不释放,程序结束时由操作系统回收

内存4区的意义:

不同区域存放的数据,赋予不同的生命周期,给我们更大的灵活编程。

C++基础_第3张图片

C++基础_第4张图片

例:

int* func()
{
    int a = 10; //局部变量,存放在栈区,栈区的数据在函数执行完后自动释放
    return &a;
}
int main()
{
    int* p = func();
    //cout<<*p<

C++基础_第5张图片

int* func()
{
    //利用new关键字 可以将数据开辟到堆区
    //指针 本质也是局部变量,放在栈上,但是指针保存的数据是放在堆区
    int *p = new int(10);
    return p;
}
int main()
{
    //在堆区开辟数据
    int* p = func();
    cout<<*p<

new 操作符

C++基础_第6张图片

//1. new的基本语法
int* func()
{
    //在堆区创建整型数据
    //new返回的是 该数据类型的指针
    int *p = new int(10);
    return p;
}
void test01()
{
    //在堆区开辟数据
    int* p = func();
    cout<<*p<

引用

int a = 10;
int &b = a;
// b是a的别名

注意:引用必须初始化,且一旦初始化后,不可以更改

引用做函数 参数

void func(int &a, int &b)
{
	int temp = a;
    a = b;
    b = temp;
}
void func2(int* a, int* b)
{
	int temp = *a;
    *a = *b;
    *b = temp;
}
int main()
{
    int a = 10;
    int b = 20;
    //引用传递
	func(a, b);
    //地址传递
    func2(&a, &b);
}

此方法不需要指针传递,该方法在C语言中不可用

引用的本质在C++内部的实现是一个指针常量

int& ref = a;

编译器会转换为 int* const ref = &a;

//发现是引用,转换为 int* const ref = &a;
void func(int& ref)
{
    ref = 100;
}
int main()
{
    //自动转换为 int* const ref = &a; 指针常量是指针指向不可改,故引用是不可更改的
    int& ref = a;
    ref = 20; //内部发现ref是引用,自动转换为 *ref = 20;
    cout<<"a:"<

常量引用

作用:常量引用主要用来修饰形参,防止误操作

const int* ref = 10;

加上const之后,编译器将代码修改 int temp = 10; const int& ref=temp;

修改为常量指针

void show(const int& v)
{
    //v += 10;
    cout<

函数重载

重载满足条件:

  • 同一个作用域下
  • 函数名称相同
  • 函数参数类型不同,或者个数或顺序不同

注意事项:函数的返回值不可以作为函数重载的条件。。。

void func(int &a) //int &a = 10不合法,赋值必须是一个合法地址
{
    cout<<"func(int &a)调用"<

类和对象

C++面向对象的三大特性:封装、继承、多态

C++认为万事万物都皆为对象,对象上有其属性和行为

封装
封装的意义:
  • 将属性和行为作为一个整体,表现生活中的事物
  • 将属性和行为加以权限控制
封装意义一:

在设计类的时候,属性与行为写在一起,表现事物。

语法

class 类名{访问权限:属性/行为};

例:设计圆类

const PI = 3.14;
class Circle
{
	//访问权限
	//公共权限
public:
	//属性--半径
    int m_r;
	//行为--获取圆的周长
	double calculateZC()
	{
        return 2* m_r * PI;
	}
};

int main()
{
    //通过圆类,创建具体的圆(对象)
    Circle c1;
    //给圆对象的属性进行赋值
    c1.m_r = 10;
    cout<<"圆的周长为:"<

方法2:通过函数给属性赋值

类中的属性和行为 统一称为 成员

属性:也叫成员属性和成员变量

行为:也叫成员函数和成员方法

Class Student
{
    //访问权限 -- 公开权限
public:
    //属性
    string m_Name;
    string m_Id;

    //行为
    //给姓名赋值,用行为给属性赋值
    void setName(string name)
    {
        m_Name = name;
    }
    void setId(string id)
    {
        m_Id = id;
    }
    void showStudent()
    {
        cout<<"学生姓名为:"<
封装意义二

访问权限有三种:

公共权限 public 此权限类内和类外都可以访问成员

保护权限 protected 此权限类内访问成员,类外不可以,但儿子可以访问父亲中的保护内容

私有权限 private 此权限类内访问成员,类外不可以,儿子也不可以

class Preson
{
public:
	string m_Name; //姓名
protected:
	string m_Car; //汽车
private:
	int m_Password; //银行卡密码
public:
	//类内可以访问
	void func()
	{
        m_Name = "张三";
        m_Car = "拖拉机";
        m_Password = 213;
    }
}

struct和class区别

默认的访问权限不同

  • struct 访问权限为公共
  • class 如果不设置权限,默认权限为私有

成员属性设为私有

成员属性一般会设为私有,优点有二。

优点1: 将所有成员属性设置为私有,可以自己控制读写权限

优点2:对于写权限,我们可以检测数据的有效性

class Person
{
public:
	//设置姓名
	void setName(string name)
	{
        m_Name = name;
    }
	void getName()
	{
        return m_Name;
    }
	// 获取年龄 只读
	int getAge()
	{
        m_Name = 0;
        return m_Name;
    }
	void m_Lover(string lover)
	{
        lover = m_lover;
    }
private:
	// 姓名 可读可写
	string m_Name;
	// 年龄 只读
	string m_Age;
	//情人 只写
	string m_Lover;
}
int main()
{
    Person p;
    p.setName("张三");
    cout<<"姓名为:"<

修改---- 年龄可读可写 且如果修改年龄范围必须在 0~100

int getAge()
{
    return m_Age;
}
//设置年龄以及范围
void setAge(int age)
{
    if(age<0 || age>100)
    {
        cout<<"范围不合适!"<

创建立方体类,并分别用全局函数和成员函数判断两个立方体是否相等

class Cube
{
public:
	void setL(int l)
	{
        m_l = l;
    }
	void setW(int w)
	{
        m_w = w;
    }
	void setH(int h)
	{
        m_h = h;
    }
	void getL()
	{
        return m_l;
    }
	void getW()
	{
        return m_w;
    }
	void getH()
	{
        return m_h;
    }
	bool isSameByClass(Cube& c)
	{
        if(m_l==c.getL() && m_w==c.getW() && m_h==c.getH())
        {
            return true;
        }
        return false;
    }
private:
	int m_l;
	int m_w;
	int m_h;
}
bool isSame(Cube& c1, Cube& c2)
{
    if(c1.getL(==c2.getL() && c1.getW()==c2.getW() && c1.getH()==c2.getH())
    {
        return true;
    }
    return false;
}

案例:查看点和圆的关系

分别设置两个类:一个是圆类,一个是点类,其中点类中存放点的x和y

Point.h

#pragma once
using namespace std;
#include
class Point
{
public:
	void setX(int x);
	void setY(int y);
	int getX();
	int getY();
private:
	int m_X;
	int m_Y;
};

Point.cpp

#include "Point.h"

void Point:: setX(int x)
{
	m_X = x;
}
void Point::setY(int y)
{
	m_Y = y;
}
int Point::getX()
{
	return m_X;
}
int Point::getY()
{
	return m_Y;
}

Circle.h

#pragma once
#include "Point.h"

class Circle
{
public:
	void setR(int r);
	void setCenter(Point center);
	int getR();
	Point getCenter();
	void isInCircle(Circle& c, Point p);
private:
	int m_R;
	Point m_Center;
};

Circle.cpp

#include "Circle.h"
void Circle::setR(int r)
{
	m_R = r;
}
void Circle::setCenter(Point center)
{
	m_Center = center;
}
int Circle::getR()
{
	return m_R;
}
Point Circle::getCenter()
{
	return m_Center;
}
void Circle::isInCircle(Circle& c, Point p)
{
	// 计算两点之间的距离的平方
	int distance = (c.getCenter().getX() - p.getX()) * (c.getCenter().getX() - p.getX()) +
		(c.getCenter().getY() - p.getY()) * (c.getCenter().getY() - p.getY());
	//计算半径 的平方
	int rDistance = c.getR() * c.getR();
	if (distance == rDistance)
	{
		cout << "点在圆上" << endl;
	}
	else if (distance > rDistance)
	{
		cout << "点在圆外" << endl;
	}
	else
	{
		cout << "点在圆内" << endl;
	}
}

main.cpp

#include
#include "Circle.h"
#include 
using namespace std;
int main()
{
    Circle c;
    Point center;
    center.setX(10);
    center.setY(10);
    Point p;
    p.setX(0);
    p.setY(11);
    c.setCenter(center);
    c.setR(10);
    c.isInCircle(c, p);
}

对象特性
对象的初始化和清理

每个对象都会有初始设置及对象销毁前的清理数据设置。

构造函数和析构函数

如果不提供构造和析构,编译器会提供编译器提供的构造函数和析构函数是空实现

构造函数:主要作用在于创建对象时为对象的成员属性赋值,构造函数由编译器自动调用,无需手动调用。

析构函数:主要作用在于对象销毁前系统自动调用,执行一些清理工作。

构造函数语法:类名(){} 构造函数没有返回值,不写void,但可以有参数,可发生重载,自动调用

析构函数语法:~类名(){} 析构函数没有返回值,不写void,不可以i有参数,不可重载。 自动调用

构造函数的分类及调用

两种分类方式:

按参数分为:有参构造和无参构造

按类型分为:普通构造和拷贝构造

三种调用方式:

括号法

显示法

隐式转换法

分类方式:

Class Person
{
public:
    Person()
    {
        cout<<"无参构造函数调用"<

调用方式

//无参构造函数调用
void test01()
{
    Person p1;
}
//有参构造函数调用
void test02()
{
    //方法1. 括号法
    Person p1(10); //有参构造
    Person p2(p1); //拷贝构造
    // 注意事项1
    //Person p();  //不可以这样调用,它会认为是对函数的声明,不会认为是在创建对象
    //方法2. 显示法
    Person p3 = Person(10);
    Person p4 = Person(p3);
    //方法3. 隐式转换法
    Person p5 = 10;// 相当于写了 Person p5 = Person(10);
    Person p6 = p5;// 相当于写了 Person p6 = Person(p5);

    //匿名对象
    Person(10);
    //注意事项2  不要利用拷贝构造函数初始化匿名对象
    //Person(p1);//编译器会认为 Person(p1)==Person p1;然而上面已经定义了p1,参数被重新定义会报错
}
拷贝构造函数调用时机
  1. 使用一个已经创建完毕的对象来初始化一个新对象
  2. 值传递方式给函数参数传值
  3. 值方式返回局部对象
//2. 值传递方式给函数参数传值
void doWork(Person p)
{

}
//3. 值方式返回局部对象
Person reWork()
{
    Person p;
    return p;
};

void test02()
{
    /*Person p1;
    doWork(p1);*/
    Person p = reWork();

    //1. 使用一个已经创建完毕的对象来初始化一个新对象
    Person p1;
    Person p2(p1);

}
构造函数调用规则

默认情况下,C++编译器至少给一个类添加3个函数

  1. 默认构造函数(无参,函数体为空)
  2. 默认析构函数(无参,函数体为空)
  3. 默认拷贝构造函数,对属性进行值拷贝

调用规则:

如果用户定义有参构造函数,C++不会再提供默认构造函数,但会提供默认拷贝构造函数。

如果拥堵定义拷贝构造函数,C++不会提供其他构造函数。

深拷贝与浅拷贝

浅拷贝:简单的赋值拷贝操作

深拷贝:在堆区重新申请空间,进行拷贝操作

将对象的属性内容创建在堆区

Class Person
{
public:
    Person(int age, int height)
    {
        age = m_Age;
        m_Height = new int(height);
        cout<<"有参构造函数调用"<

出错原因:浅拷贝只拷贝地址,而当p2调用析构函数销毁指向的堆区0x0011后,p1也会调用析构函数继续销毁堆区0x0011,因为m_Height存放的地址相同。然而现在0x0011堆区已经被销毁,故会出错。

C++基础_第7张图片

深拷贝:

C++基础_第8张图片

Person(const Person& p)
{
    //将传入的人身上的所有属性,拷贝到我身上
    m_Age = p.m_Age;
    //m_Height = p.m_Height; //编译器默认实现的拷贝构造函数
    //深拷贝
    m_Height = new int(*p.m_Height);
    cout << "Person的拷贝构造调用" << endl;
};

总结:如果属性有在堆区开辟的,一定要自己提供拷贝构造函数,防止浅拷贝带来的问题。

初始化列表

作用:C++提供了初始化列表语法,用来初始化属性

Class Person
{
public:
    //传统方式初始化
    Person(int a, int b, int c)
    {
        m_A = a;
        m_B = b;
        m_C = c;
    }
    //初始化列表
    // Person(): m_A(10), m_B(20), m_C(30)
    // {
        
    // }
    //或
    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;
};

类对象作为类成员

class Phone
{
public:
    Phone(string name)
    {
        name = m_PhoneName;
    }
    string m_PhoneName;
};
class Person2
{
public:
    //相当于 Phone m_Phone = phone_Name; 隐式转换法
    Person2(string name, string phone_Name) : m_Name(name), m_Phone(phone_Name)
    {

    }
    string m_Name;
    Phone m_Phone;
};

当其他类对象作为本类成员,构造时候先构造类对象,再构造自身;

析构的顺序与之相反。

静态成员

静态成员分为静态成员变量和静态成员函数

静态成员变量
  • 所有对象共享同一份数据
  • 在编译阶段分配内存
  • 类内声明,类外初始化
class Person
{
	static int m_A;
};
int Person::m_A = 100;
void test01()
{
    Person p;
    //100
    cout<

静态成员变量有两种访问方式

//1. 通过对象进行访问
Person p;
cout<
静态成员函数
  • 所有对象共享同一个函数
  • 静态成员函数只能访问静态成员变量

静态成员函数也有两种访问方式

void test()
{
    Person p;
    p.func();
    Person::func();
}

只能访问静态成员变量

class Person
{
public:
	static void func()
	{
        m_A = 100; 静态成员函数 可以访问 静态成员变量
        //m_B = 200; //静态成员函数 不可以访问 非静态成员变量,因为无法区分到底是哪个对象的变量
        cout<<"stataic void func调用"<
成员变量和成员函数分开存储
class Person
{

};
void test
{
    Person p;
    //空对象占用内存空间为:1
    //C++编译器会给每个空对象也分配一个字节空间,是为了区分空对象占内存的位置
    //每个空对象也应该有一个独一无二的内存地址
    cout<<"size of p = "<
class Person
{
	int m_A; //非静态成员变量 属于类的对象上
	static int m_B; //静态成员变量 不属于类的对象上
	void func(){} //非静态成员函数 不属于类对象上
	static void func2(){} //静态成员函数,属于类的对象上
};
void test
{
    Person p;
    //对象占用内存空间为:4
    cout<<"size of p = "<

只有非静态成员变量属于类的对象上

this指针

C++基础_第9张图片

this指针指向 被调用的成员函数 所属的对象

用途1. 解决名称冲突

class Person
{
	Person(int age)
	{
        this->age = age;
    }
	int age;
};
void test01()
{
    Person p1(18);
    cout<<"p1年龄:"<

用途2:返回对象本身用*this

class Person
{
	Person(int age)
	{
        this->age = age;
    }
	Person& PersonAddAge(Person& p)
	{
        this->age += p.age;
        //this指向p2的指针,而*this指向的就是p2这个对象本体
        return *this;
    }
	int age;
};
void test01()
{
    Person p1(10);
    Person p2(10);
    //链式编程思想
    p2.PersonAddAge(p1).PersonAddAge(p1).PersonAddAge(p1);
    cout<<"p2年龄:"<
空指针访问成员函数
class Person
{
public:
	void showClassName()
	{
        cout<<"this is Person class"<const修饰成员函数 
  

常函数:

  • 成员函数后加const后我们称为这个函数为常函数
  • 常函数不可以修改成员属性
  • 成员属性声明时加关键字mutable后,在常函数中依然可以修改

常对象:

  • 声明常对象前加const称该对象为常对象
  • 常对象只能调用常函数
//常函数
class Person3 {
public:
    //this 指针的本质是指针常量,指针的指向是不可以修改的,但指向的值可以修改
    //Person* const this;
    //如果想让指向的值也不可修改,则需要改为 const Person* const this;
    //在成员函数后面加const,修饰的是this指向,如果想让指向的值也不可修改
    void showPerson() const
    {
        this->m_B = 100;
        //this->m_A = 100;
        //this = NULL; //this指针不可以修改指针的指向
    }
    void func()
    {
        m_A = 100;
    }
    int m_A;
    mutable int m_B; //特殊变量,即使在常函数中,也可以修改这个值,加上关键字mutable
};
void test05()
{
    Person3 p;
    p.showPerson();
}
//常对象
void test06()
{
    const Person3 p;//在对象前加const,变为常对象
    //p.m_A = 100;
    p.m_B = 100; //m_B是特殊值,在常对象下也可以修改
    //常对象只能调用常函数
    //p.func(); //常对象 不可以调用普通成员函数,因为普通成员函数可以修改属性
}

你可能感兴趣的:(c++,算法,c++)