基于学会C语言的C++补充笔记（自用）

GodBlessTzw

已于 2023-10-19 20:14:19 修改

阅读量61

点赞数

文章标签： c++

于 2023-10-11 19:27:09 首次发布

本文链接：https://blog.csdn.net/qq_53758507/article/details/133776483

版权

C++基本框架

#include <iostream>

using namespace std;

int main(){
    
    cout << "hello c++" << endl;
    return 0;
}

求数组元素个数        sizeof(arr)/sizeof(arr[0])

二维数组内存空间        sizeof(arr)

        第一行内存空间        sizeof(arr[0])

        第一个元素内存        sizeof(arr[0][0])

根据上面信息行数计算，列数计算？

函数的分文件编写

//swap.h文件
#include <iostream>

using namespace std;

int swap(int a,int b);


//swap.cpp文件
#include "swap.h"

int swap(int a,int b) {
    return a + b;
}

//main文件
#include <iostream>
#include "swap.h"

using namespace std;

int main() {
    swap(1,2);
    return 0;
}

const修饰符

//const修饰指针

int a = 10;

const int * p = &a;        //常量指针    可以乱指，但指到的内容不可改变
int * const p = &a;        //指针常量    不可以乱指，指到的内容可以更改

const int * const p = &a;    //都不可更改

new和delete的使用

//堆区开辟内存
int *p = new int(10);
int *arr = new int[10];

delete p;
delete[] arr;

引用的学习

//引用的学习
int a = 10;

int &b = a;
//必须初始化、初始化后不能再改

//不要返回局部变量的引用，或者说不要返回局部变量的地址

//static修饰的静态变量在全局变量区 程序结束后系统才释放

int& test02(){
    static int a = 10;
    return a;
}

int main() {
    
    int& ref = test02();
    cout << ref << endl;
    test02() = 1000;    //引用做函数返回值 函数可以作为左值
    cout << ref << endl;
}

//引用的本质 就是 指针常量
int &ref = a;
int * const ref = &a;        //其实就是保护指针不要乱指

//常量引用 即连改都不能改 只读了

函数的参数

//函数的默认参数
int func(int a, int b = 20, int c = 30) {
    return a + b + c;
}

int main() {
    func(10);        //60
    func(10,30);     //70
}

//如果某个位置已经有了默认参数 那么这个位置之后 都必须有默认值
//函数的声明和实现 只能有一个写默认参数

//函数占位参数
void func(int a, int) {}         //调用时必须传两个参数
void func(int a, int = 10) {}    //调用时可以只传一个参数

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

类

//类和对象

class Person {

public:
    string name;    //类内类外
protected:
    string car;     //类内 孩子
private:
    int password;   //类内

public:
    string getname(){
        return name;
    }
}

class和struct的区别

//class 和 struct 区别 默认权限分别是 private 和 public

//构造函数 和 析构函数
class flower{
    flower() {}        //可以有参数 可以重载 创建对象自动调用 仅一次

    ~flower() {}       //不可以有参数 不可重载 对象销毁前自动调用 仅一次
}

构造函数和析构函数

#include <iostream>

using namespace std;

class Person {
public:
	//不写调用默认 写了调用此 没有返回值 可以有参数重载 创建对象只调一次
	Person() {
		cout << "构造函数" << endl;
	}

	//不能有参数 对象销毁前只调一次
	~Person() {
		cout << "析构函数" << endl;
	}

};

int main() {

	Person p1;
	system("pause");
	return 0;
}

#include <iostream>

using namespace std;

class Person {
public:
	
	Person() {
		cout << "无参构造函数" << endl;
	}
	
	Person(int a) {
		age = a;
		cout << "有参构造函数" << endl;
	}

	Person(const Person &p) {
		age = p.age;
		cout << "拷贝构造函数" << endl;
	}

	~Person() {
		cout << "析构函数" << endl;
	}
	int age;
};

int main() {
	//括号法
	Person p1;			//默认构造函数的调用 注意不允许加()
	Person p2(10);		//有参构造函数的调用
	Person p3(p2);		//拷贝构造函数的调用

	//显式法
	Person p4;
	Person p5 = Person(10);
	Person p6 = Person(p5);
	Person(10);	//匿名对象 当前行执行结束后系统会立即回收

	//不要用拷贝构造函数初始化匿名对象
	Person(p3);//Person(p3) === Person p3

	//隐式法
	Person p7 = 10;	//Person p4 = Person(10);
	Person p8 = p7;

	//构造函数的时机 1.以上三种调用 2.作为函数参数 值传递 3.作为 函数返回值 返回

	//编译器默认提供 1.无参构造函数 2.析构函数 3.拷贝构造函数
	//若你写了有参构造函数 就不再提供1 但是还提供3
	//若你写了3 就不再提供1和3
	return 0;
}

深拷贝与浅拷贝

#include <iostream>

using namespace std;

class Person {

public:

	Person() {
		cout << "无参构造函数" << endl;
	}
	
	Person(int a) {
		age = a;
		cout << "有参构造函数" << endl;
	}

	//系统提供 浅拷贝
	/*
	Person(const Person &p) {
		age = p.age;
		height = p.height;
		cout << "拷贝构造函数" << endl;
	}*/

	//深拷贝
	Person(const Person &p) {
		age = p.age;
		height = new int(*p.height);
		cout << "拷贝构造函数" << endl;
	}

	~Person() {
		//将堆区开辟数据释放
		if (height != NULL) {
			delete height;
			height = NULL;
		}
		cout << "析构函数" << endl;
	}

	int age;
	int *height;
};

int main() {
	
	//系统提供的拷贝构造是浅拷贝 比如会导致两个对象的指针成员指向同一个属性 会导致堆区的内存重复释放


	return 0;
}

初始化列表

#include <iostream>

using namespace std;

class Person {

public:
	//初始化列表初始化属性
	Person(int a,int b,int c) :m_a(a), m_b(b), m_c(c) {

	}
private:
	int m_a, m_b, m_c;

};

int main() {
	
	return 0;
}

其他类对象作为本类成员，先构造类对象在构造自身，析构顺序与之相反

静态成员

静态成员变量

所有对象共享一份，编译时分配内存，类内声明类外初始化

静态成员函数

所有对象共享一个函数，静态函数只能访问静态变量

#include <iostream>

using namespace std;

class Person {

public:
	static int m_A;
};

//可以用类名访问静态变量
int Person::m_A = 100;

int main() {
	
	Person p1;
	p1.m_A = 200;	//也可以用对象名访问静态变量

	return 0;
}