【C++】从c语言过渡到c++入门

念_ovo

已于 2024-01-20 00:36:36 修改

阅读量149

点赞数 1

文章标签： c++ c语言算法

于 2023-11-04 21:33:14 首次发布

本文链接：https://blog.csdn.net/qq_72680384/article/details/134223767

版权

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;
}