c++自学日记 day7

清风0407

于 2024-05-21 22:53:14 发布

阅读量371

点赞数 5

文章标签： c++ 开发语言

本文链接：https://blog.csdn.net/m0_74214396/article/details/139094179

版权

1、c++初始化列表和构造函数的区别：
先说结论：初始化列表比构造函数更快，泛用性也更广，具体可以参考这篇帖子：
为什么使用初始化列表会快一些？ - 知乎 (zhihu.com)（侵权联系删除）

2、

类对象作为类成员

C++类中的成员可以是另一个类的对象，我们称该成员为对象成员

例如：

class A {}
class B
{
    A a；
}

B类中有对象A作为成员，A为对象成员

那么当创建B对象时，A与B的构造和析构的顺序是谁先谁后？

(A先构造B再构造，析构时B先析构A再析构）

class Phone
{
public:
	Phone(string name)
	{
		m_PhoneName = name;
		cout << "Phone构造" << endl;
	}

	~Phone()
	{
		cout << "Phone析构" << endl;
	}

	string m_PhoneName;

};


class Person
{
public:

	//初始化列表可以告诉编译器调用哪一个构造函数
	Person(string name, string pName) :m_Name(name), m_Phone(pName)
	{
		cout << "Person构造" << endl;
	}

	~Person()
	{
		cout << "Person析构" << endl;
	}

	void playGame()
	{
		cout << m_Name << " 使用" << m_Phone.m_PhoneName << " 牌手机! " << endl;
	}

	string m_Name;
	Phone m_Phone;

};
void test01()
{
	//当类中成员是其他类对象时，我们称该成员为 对象成员
	//构造的顺序是 ：先调用对象成员的构造，再调用本类构造
	//析构顺序与构造相反
	Person p("张三" , "苹果X");
	p.playGame();

}


int main() {

	test01();

	system("pause");

	return 0;
}

3、静态变量相关

静态成员

静态成员就是在成员变量和成员函数前加上关键字static，称为静态成员

静态成员分为：

静态成员变量
- 所有对象共享同一份数据
- 在编译阶段分配内存
- 类内声明，类外初始化
静态成员函数
- 所有对象共享同一个函数
- 静态成员函数只能访问静态成员变量

class Person
{
	
public:

	static int m_A; //静态成员变量

	//静态成员变量特点：
	//1 在编译阶段分配内存
	//2 类内声明，类外初始化
	//3 所有对象共享同一份数据

private:
	static int m_B; //静态成员变量也是有访问权限的
};
int Person::m_A = 10;
int Person::m_B = 10;

void test01()
{
	//静态成员变量两种访问方式

	//1、通过对象
	Person p1;
	p1.m_A = 100;
	cout << "p1.m_A = " << p1.m_A << endl;

	Person p2;
	p2.m_A = 200;
	cout << "p1.m_A = " << p1.m_A << endl; //共享同一份数据
	cout << "p2.m_A = " << p2.m_A << endl;

	//2、通过类名
	cout << "m_A = " << Person::m_A << endl;


	//cout << "m_B = " << Person::m_B << endl; //私有权限访问不到
}

int main() {

	test01();

	system("pause");

	return 0;
}

class Person
{

public:

	//静态成员函数特点：
	//1 程序共享一个函数
	//2 静态成员函数只能访问静态成员变量
	
	static void func()
	{
		cout << "func调用" << endl;
		m_A = 100;
		//m_B = 100; //错误，不可以访问非静态成员变量
	}

	static int m_A; //静态成员变量
	int m_B; // 
private:

	//静态成员函数也是有访问权限的
	static void func2()
	{
		cout << "func2调用" << endl;
	}
};
int Person::m_A = 10;


void test01()
{
	//静态成员变量两种访问方式

	//1、通过对象
	Person p1;
	p1.func();

	//2、通过类名
	Person::func();


	//Person::func2(); //私有权限访问不到
}

int main() {

	test01();

	system("pause");

	return 0;
}

下列是本人测试自用：

#include <iostream>
#include <string>
using namespace std;
class test {
public:
    int a,b,c;
    static int st;
    //test(int a, int b, int c) :c(a), b(b), a(c) {}//初始化列表写法，比传统的更简洁
    test(int a, int b, int c) {
        this->a = a;
        this->b = b;
        this->c = c;//当形参名与对象名相同，应该使用this->以作区分
    }
    void printtest() {
        cout << "t_a= " << a << endl;
        cout << "t_b= " << b << endl;
        cout << "t_c= " << c << endl;
    }
    test& add_a(test& t1) {//未加&引用，返回值只是一个副本，不是其本身
        this->a += t1.a + 10;
        return *this;

    }
    static void func() {
        cout << "静态函数调用" << endl;
        cout << "调用静态变量" << st << endl;
        //cout << "调用非静态变量" << a << endl; 不可调用非静态变量
    }
};
int test::st = 10;
int main() {

    test s1(3,2,1);
    s1.st;
    test s2(2, 2, 2);
    //s1.add_a(s2).add_a(s2).add_a(s2).add_a(s2);//链式编程
    //s1.printtest();
    cout << "对象调用静态变量：" << s1.st << endl;//通过对象访问静态变量
    cout << "类名调用静态变量：" << test::st << endl;//类名访问
    s1.func();
    test::func();
    return 0;
}

4、

成员变量和成员函数分开存储

在C++中，类内的成员变量和成员函数分开存储

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

（PS：空对象占一个字节）

class Person {
public:
	Person() {
		mA = 0;
	}
	//非静态成员变量占对象空间
	int mA;
	//静态成员变量不占对象空间
	static int mB; 
	//函数也不占对象空间，所有函数共享一个函数实例
	void func() {
		cout << "mA:" << this->mA << endl;
	}
	//静态成员函数也不占对象空间
	static void sfunc() {
	}
};

int main() {

	cout << sizeof(Person) << endl;

	system("pause");

	return 0;
}

5、

this指针概念

通过4.3.1我们知道在C++中成员变量和成员函数是分开存储的

每一个非静态成员函数只会诞生一份函数实例，也就是说多个同类型的对象会共用一块代码

那么问题是：这一块代码是如何区分那个对象调用自己的呢？

c++通过提供特殊的对象指针，this指针，解决上述问题。this指针指向被调用的成员函数所属的对象

this指针是隐含每一个非静态成员函数内的一种指针

this指针不需要定义，直接使用即可

this指针的用途：

当形参和成员变量同名时，可用this指针来区分
在类的非静态成员函数中返回对象本身，可使用return *this（在返回对象本身时，函数名前要加&，返回的才是对象本身，不加返回的则是一个副本）

class Person
{
public:

	Person(int age)
	{
		//1、当形参和成员变量同名时，可用this指针来区分
		this->age = age;
	}

	Person& PersonAddPerson(Person p)//要用&返回的才是对象本身，不加&则是一个副本
	{
		this->age += p.age;
		//返回对象本身
		return *this;
	}

	int age;
};

void test01()
{
	Person p1(10);
	cout << "p1.age = " << p1.age << endl;

	Person p2(10);
	p2.PersonAddPerson(p1).PersonAddPerson(p1).PersonAddPerson(p1);
	cout << "p2.age = " << p2.age << endl;
}

int main() {

	test01();

	system("pause");

	return 0;
}

本人自写（仅测试练习）

#include <iostream>
#include <string>
using namespace std;
class test {
public:
    int a,b,c;
    static int st;
    //test(int a, int b, int c) :c(a), b(b), a(c) {}//初始化列表写法，比传统的更简洁
    test(int a, int b, int c) {
        this->a = a;
        this->b = b;
        this->c = c;//当形参名与对象名相同，应该使用this->以作区分
    }
    void printtest() {
        cout << "t_a= " << a << endl;
        cout << "t_b= " << b << endl;
        cout << "t_c= " << c << endl;
    }
    test& add_a(test& t1) {//未加&引用，返回值只是一个副本，不是其本身
        this->a += t1.a + 10;
        return *this;

    }
    static void func() {
        cout << "静态函数调用" << endl;
        cout << "调用静态变量" << st << endl;
        //cout << "调用非静态变量" << a << endl; 不可调用非静态变量
    }
};
int test::st = 10;
int main() {

    test s1(3,2,1);
    s1.st;
    test s2(2, 2, 2);
    //s1.add_a(s2).add_a(s2).add_a(s2).add_a(s2);//链式编程
    //s1.printtest();
    cout << "对象调用静态变量：" << s1.st << endl;//通过对象访问静态变量
    cout << "类名调用静态变量：" << test::st << endl;//类名访问
    s1.func();
    test::func();
    return 0;
}