【C++】类（public，private）

最新推荐文章于 2025-03-30 09:49:36 发布

mjiansun

最新推荐文章于 2025-03-30 09:49:36 发布

阅读量1.9w

点赞数 30

分类专栏： C++

本文链接：https://blog.csdn.net/u013066730/article/details/84347173

版权

C++ 专栏收录该内容

120 篇文章

订阅专栏

本文深入探讨C++中类的定义与使用，包括访问修饰符、this指针的运用、重名问题解决策略，以及类的封装和头文件与源文件的分离实践。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

说到类，就不得不提struct（对照struct博客来理解类），毕竟类是再struct的基础上进行了功能增强。

class Object
{
    int a;
    int b;
    double c;
};

访问修饰符

public：表示类的成员可以被外部访问；

private：表示类的成员不可以被外部访问。

class Object
{
public:
    int a;
    int b;
    void Test()
    {
        printf("Hello, i am test.\n");
    }
private:
    double c;
};


int main()
{
    Object a;
    a.a = 1;
    a.b = 2;
    a.Test();

    Object* b = &a;
    printf("%d \n", b->a);
    std::cout << "Hello World!\n"; 
    return 0;
}

this指针

其实就是为了方便，不然你要手动传对象指针，比较人性化点。

#include "stdio.h"

class Object
{
public:
    int a;
    int b;
    //传统C语言方式，传一个指针进去
    void Test(Object* that)
    {
        printf("Hello, i am test.\n");
        printf("C:%d\n", that->a);
    }
    //C++直接就在类内部实现了这个功能
    void Test_CPP()
    {
    printf("CPP:%d \n", this->b);
    }
    
    int Add()
    {
        return this->a + this->b;
    }
	//C++直接就在类内部实现了这个功能
    void Test_add()
    {
        printf("Add:%d \n", this->Add());
    }
};

int main()
{
    Object a;
    a.a = 1;
    a.b = 2;
    a.Test(&a);
    a.Test_CPP();
    a.Test_add();
    
    std::cout << "Hello World!\n"; 
    return 0;
}

就算被private修饰，在class内部依旧可以使用，反正都是自己的怕什么，随便用。例子：

#include "stdio.h"

class Object
{
private:
    int a;
    int b;
	//传统C语言方式，传一个指针进去

public:
    void Set_value(int a, int b)
    {
        this->a = a;
        this->b = b;
    }
    int Add()
    {
        return this->a + this->b;
    }
	//C++直接就在类内部实现了这个功能
    void Test_add()
    {
        printf("Add:%d \n", this->Add());
    }

    void Print_this()
    {
        printf("this:%p\n", this); //打印this地址
    }
};

int main()
{
    Object a;
    printf("a:%p\n", &a);//打印对象地址
    a.Print_this();
    a.Set_value(2, 6); //设置值
    a.Test_add(); //加法并打印

    std::cout << "Hello World!\n";
    return 0;
}

可以看出对象a和this的指针是一样的。

this->可以省略

就是在类的内部可以不用this也能使用本身的变量和函数。

#include "stdio.h"

class Object
{
private:
	int a = 1;
	int b = 3;
	//传统C语言方式，传一个指针进去

public:
	void Set_value(int a, int b)
	{
		this->a = a;
		this->b = b;
	}

	int Add()
	{
		return this->a + this->b; //相当于 return a + b;
	}

	int Reduce()
	{
		return a - b;
	}

	void Test_func()
	{
		printf("Reduce:%d \n", this->Reduce());
	}

	void Print_this()
	{
		printf("this:%p\n", this);
	}
};

int main()
{
	Object a;
	printf("a:%p\n", &a);
	a.Print_this();
	a.Set_value(2, 6); //设置值
	a.Test_func(); //加法并打印

	std::cout << "Hello World!\n";
	return 0;
}

重名问题（就近原则）

第一种：传入参数名与类中变量名重复

#include "stdio.h"

class Object
{
public:
    int a;
    int b;

    void Test_func(int a)
    {
        printf("Repeat:%d \n", a);
    }

};

int main()
{
    Object a;
    a.a = 10;
    a.Test_func(5); //加法并打印

    std::cout << "Hello World!\n";
    return 0;
}

结果为：

Repeat:5

Hello World

分析：从结果看出Test_func中的参数是a=5，类中也有一个变量a=10，它两值不一样，最终打印了传入的值5。所以这符合就近原则。如果想调用类中的a，可以使用this->a

第二种：类中变量名与全局变量名重复

使用::调用全局变量

#include "stdio.h"

int a = 100; //全局变量

class Object
{
public:
    int a;
    int b;

    void Test_func()
    {
        printf("Repeat:%d \n", ::a);
    }

};

int main()
{
    Object a;
    a.a = 10;
    a.Test_func(); //加法并打印

    std::cout << "Hello World!\n";
    return 0;
}

其结果为：

Repeat:100

Hello World

打印了全局变量，因为我在a前面加了限定符::

第三种：类中函数名和全局函数名重复

访问全局函数，在函数名前加入::

#include "stdio.h"

int a = 100; //全局变量

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

class Object
{
public:
    int a;
    int b;

    int Sum(int a, int b)
    {
        return a*2 + b;
    }

    void Test_func()
    {
        printf("Repeat:%d \n", ::Sum(a, b)); // 访问全局Sum函数
    }

};

int main()
{
    Object a;
    a.a = 10;
    a.b = 20;
    a.Test_func(); //加法并打印

    std::cout << "Hello World!\n";


    return 0;
}

命名规范

类名：名词，首字母大写（也可以加下划线分隔）

成员函数：动词，首字母大写（也可以加下划线分隔）

成员变量：小写字母，通常加上前缀m_（我感觉这个无所谓了，定义的名字有实际意义就行）

类的封装

封装，顾名思义就是将内部实现封装成一个黑盒，只提供接口，其他使用者只能通过接口调用。

封装其实就是通过访问修饰符来实现的。

#include "stdio.h"

class Object
{
private:
    int m_a;
    int m_b;
    int m_radius;

public:
    int GetA() //只读功能
    {
        return m_a;
    }

    int GetB()
    {
        return m_a;
    }

    int SetRadius(int radius) //只写功能
    {
        this->m_radius = radius;
    }
};

类的头文件和源文件分离

（1）成员变量，还是写在类里面

（2）成员函数，在类里面保留申明，而函数的具体实现写在类体之外；

（3）写在类体之外的函数记得加上Object::（类名::）

#include "stdio.h"

class Object
{
public:
    int x;
    void Test();
};

void Object::Test()
{
    printf("This is outside implementation.");
}

int main()
{
    Object obj;
    obj.Test();
    std::cout << "Hello World!\n";

    return 0;
}

头文件和类的实现分离时，要注意编译器环境。

main.cpp

#include "pch.h"
#include <iostream>
#include "Object.h"


int main()
{
	Object obj;
	obj.x = 1;
	obj.Test();
	std::cout << "Hello World!\n";

	return 0;
}

Object.cpp

#include "pch.h"
#include "Object.h"
#include "iostream"
using namespace std;

void Object::Test()
{
	cout << "x is " << x << endl;
}

Object.h

头文件一般情况下要加入#ifndef #define #endif，这样可以防止该头文件被重复定义。

我们得了解到include就相当于将对应的.h头文件直接copy到主程序中，如果你引用了2次头文件，岂不是说你申明了2个完全相同的变量或者函数，这显然是不被允许的。所以就得加#ifndef #define #endif

#pragma once
#ifndef _OBJECT_H
#define _OBJECT_H

class Object
{
public:;
	int x;
	void Test();
};

#endif

请注意：

（1）不一定要将所有函数都拿到cpp中实现，在头文件中也是可以写函数的实现的。

但一般情况，只给用户看接口，具体的实现时不让用户看得的，所以就需要将实现都写到cpp中。

那么写在类体之内和类体之外有什么区别呢？

写在类体里面相当于inline函数，写在类体之外，则是普通的函数。

（2）在类体中，成员函数与成员变量的排列顺序是自由的。