C++复习笔记

最新推荐文章于 2022-03-11 18:27:34 发布

绝黛雨儿

最新推荐文章于 2022-03-11 18:27:34 发布

阅读量524

点赞数 1

分类专栏： C/C++ 文章标签： c++

本文链接：https://blog.csdn.net/alive2012/article/details/50917018

版权

C/C++ 专栏收录该内容

20 篇文章 0 订阅

订阅专栏

C++研究笔记

工程化

A.h

成员函数1；
成员函数2；


A.c

#include"A.h"

A::成员函数1{}
A::成员函数2{}

demo.c

#include"A.h"

int main()
{
  todo...
}

相比于C,C++的新特性

C++有布尔类型,C没有哦…

初始化方法

复制初始化 int x = 1024; (C语言有的特性)
直接初始化 int x(1024);

随用随定义

C语言:所有变量定义必须位于函数体的前面
随用随定义

输入输出方式

C++

不用关心占位符；譬如 %d ,%f …
不用关心数据类型

cout << oct|dec|hex|boolalpha << x <

OOP

数据的封装

class Student
{
  public:
    void setAge(int _age){age = _age;}
    int getAge(){return age;}
  private:
    string name;
    int age;
}

可以设置只读属性,类的封装不设置对外写接口

内联函数

类内定义的函数优先选择编译为内联函数

内联函数

类外定义

同文件类外定义类名::成员{}
分文件类外定义文件名类名.h 调用者: #include”类名.h” 类名::成员{}

构造函数

构造函数在对象实例化时被自动调用,且仅调用一次
构造函数与类同名
构造函数没有返回值
构造函数可以有多个重载形式
实例化对象时仅用到一个构造函数
当用户没有定义构造函数时,编译器自动生成一个构造函数

初始化列表

student():m_strName("rose"),m_iAge(20){}

初始化列表先于构造函数执行
初始化列表只能用于构造函数

侯捷老师提到过推荐使用初始化列表

初始化列表可以征服const声明的常量,个人感觉就像先执行初始化列表,进行变量m_Age的初始化,然后const修饰将变量转换成常量

person(int age):m_Age(age){}

private:
const int m_Age;

拷贝构造函数

定义

类名(const 类名 &变量名)

没有定义拷贝构造函数,系统会自动生成一个默认的拷贝构造函数
直接初始化,复制初始化,系统自动调用拷贝构造函数

整个对象的拷贝

析构函数

~类名(){}

对象数组

Coordinage coor[3] //栈实例化对象数组
coor[0].m_iX  //访问成员

Coordinate *p = new Coordinate[3];  //堆实例化对象数组
p[0].m_iX  // p->m_iX 

p++;

P->m_iX;   // 第二个单元

深拷贝与浅拷贝

浅拷贝

*两个实例化对象指向同一块内存,最后操作的对象总是覆盖掉前一对象的操作；释放内存时,能够导致内存的二次释放

深拷贝

重新申请内存
传入对象的内存赋值给新申请的内存,通常用遍历的方式来赋值

Test(const Test& arr){

    m_pArr = new int[m_iCount];
    for(int i=0;i<m_iCount;i++)
    {
      m_pArr[i] = arr.m_pArr[i];
    }

}

对象指针

Coordinate *p = new Coordinate;

p->member;
(*p).member; //这个最是让自己匪夷所思的,p指向了Obj,*p的意思就是读取了Obj

#include <iostream>
using namespace std;
class Coordinate
{

public:
    Coordinate()
    {
    }
    // 打印坐标的函数
    void printInfo()  
    {
        cout<<"("<<m_iX<<","<<m_iY<<")"<<endl;
    }
public:
    int m_iX;
    int m_iY;
};
int main(void)
{
    //定义对象数组
    Coordinate *coorArr = new Coordinate[2];
    coorArr[0].m_iX = 1;
    coorArr[0].m_iY = 2;
    coorArr[1].m_iX = 3;
    coorArr[1].m_iY = 4;


    //遍历数组，打印对象信息
    for(int i = 0; i < 2; i++)
    {
        coorArr[i].printInfo();
    }   
    return 0;
}

指针访问对象数组成员:指针名[偏移量].成员

测试
1. &coorArr[0] 打印出来的结果是地址,coorArr[0]是一个数值嘛?
2. 测试结果,error,姑且就把它当作对象看待

对象成员指针

class Line
{
public:
    Line();
    ~Line();
private:
    Coordinate *m_pCoorA;
    Coordinate *m_pCoorB;
}

Line::Line()
{
    m_pCoorA = new Coordinate(1,3);
    m_pCoorB = new Coordinate(5,6);

}

Line::~Line()
{
    delete m_pCoorA;
    delete m_pCoorB;
}

对象成员指针

this指针

解决参数与数据成员同名
this指针在参数列表中的位置

return (*this) //返回一个对象
返回引用对象,比如第一次操作改变了成员变量,第二次操作返回对象.成员变量,变量会发生改变
如果直接返回一个对象,第二次操作不会改变变量

this指针的特殊用法

#include<iostream>
using namespace std;

class Array
{
    public:
    Array(int len):m_len(len)
    {
        cout<<"构造函数"<<endl;
    }

    void set(int len)
    {
        m_len = len;
    }

    int get()
    {
        return m_len;
    }

    Array printinfo()
    {
        cout<<"m_len= "<<m_len<<endl;
        return (*this);
    }

    private:
    int m_len;
};

测试程序1

int main()
{
        Array arr1(10);
        arr1.printinfo().set(5);
        cout<<arr1.get()<<endl;
        return 0;
}

测试结果arr1的数值没有发生改变,因为返回的另外一个对象,该对象为临时对象

解决方法

Array& printinfo()
{
    cout<<"m_len= "<<m_len<<endl;
    return (*this);
}

将返回对象修改为返回引用,指向同一个内存区域,就可以测试成功

返回对象修改为对象指针

Array* printinfo()
{
    cout<<"m_len= "<<m_len<<endl;
    return this;
}

int main()
{
        Array arr1(10);
        arr1.printinfo()->set(5);
        cout<<arr1.get()<<endl;
        return 0;
}

const

const int * p = int const *p

const修饰的是(*p) , 即指针指向的数值,数值为常量

int * const p

const修饰的是p, 指针为常量

int x=3 const int &y = x x=0正确,y=20错误(const修饰了引用y,y为常量,不可以赋值)
int x =3 (变量) const int x= 3 (常量)
- 如果成员变量前const修饰,那么构造函数在函数体内定义,这样的方法会产生error;但是倘若使用初始化列表的方法的话,程序会成功,初始化列表完成了成员变量的初始化,然后const修饰,之后成员变量为常量,不可进行赋值操作了.
- 常对象成员,也可以用初始化列表这样的技术手段

常成员函数

函数 const;

常成员函数中不能改变成员变量的数值

void change() const
{
m_iX = 10;
}

void change(const *this)
{
this->m_iX = 10; //error const修饰了(*p)指向的数值,数值为常量
}

//互为重载
void changeX() const;
void changeX();
调用的时候需要前面const来区分,否则调用普通函数,而不是常成员函数
常成员函数的本质是内部使用常this指针
常成员函数内不能调用普通的成员函数

常指针与常引用

int main(void)
{
    Coordinate coor1(3,5);
    const Coordinate &coor2 = coor1;
    const Coordinate *pCoor3 = &coor1;

    coor1.printInfo();
    coor2.getX();  //error getX()要求传入读写权限的参数,而coor2传入的this指针只有读权限   
    pCoor3->getY(); //error ...同上
    return 0;
}