C++类成员相关应用方法介绍(C++ 类成员应用技巧详解)

原创

ithorizon 6个月前 (10-20) 阅读数 12 #后端开发

C++ 类成员相关应用方法介绍

一、引言

在C++编程中，类成员是构成类的基本元素，包括数据成员和成员函数。合理地使用类成员可以减成本时间代码的可读性、可维护性和扩展性。本文将详细介绍C++类成员的相关应用方法，帮助读者掌握类成员的使用技巧。

二、数据成员的应用方法

数据成员是类的属性，用于存储类对象的状态。以下是一些数据成员的应用方法：

1. 封装

封装是面向对象编程的核心原则之一，通过将数据成员设置为私有，仅通过公有成员函数访问，可以保护数据成员不被外部直接修改，从而确保对象的状态保持一致。


class Person {
private:
    std::string name;
    int age;
public:
    Person(const std::string& name, int age) : name(name), age(age) {}
    std::string getName() const {
        return name;
    }
    int getAge() const {
        return age;
    }
    void setName(const std::string& newName) {
        name = newName;
    }
    void setAge(int newAge) {
        age = newAge;
    }
};

2. 初始化

类的构造函数中应对数据成员进行初始化，以确保对象在创建时具有确定的初始状态。


class Rectangle {
private:
    double width;
    double height;
public:
    Rectangle(double w, double h) : width(w), height(h) {}
    double getWidth() const {
        return width;
    }
    double getHeight() const {
        return height;
    }
    double getArea() const {
        return width * height;
    }
};

3. 数据成员的默认值

当类成员有默认值时，可以在声明时指定，这样创建对象时如果没有提供相应的参数，成员变量将自动被赋予默认值。


class Student {
private:
    std::string name;
    int age = 18;  // 默认值为18
public:
    Student(const std::string& name) : name(name) {}
    int getAge() const {
        return age;
    }
};

三、成员函数的应用方法

成员函数是类的方法，用于对类的对象进行操作。以下是一些成员函数的应用方法：

1. 构造函数和析构函数

构造函数用于初始化对象，析构函数用于在对象销毁前进行清理工作。


class Car {
private:
    std::string brand;
    int year;
public:
    Car(const std::string& brand, int year) : brand(brand), year(year) {
        std::cout << "Car created. ";
    }
    ~Car() {
        std::cout << "Car destroyed. ";
    }
    std::string getBrand() const {
        return brand;
    }
    int getYear() const {
        return year;
    }
};

2. 成员函数的默认参数

类的成员函数可以像普通函数一样具有默认参数，这增长了函数的灵活性。


class Book {
private:
    std::string title;
    std::string author;
    int year;
public:
    Book(const std::string& title, const std::string& author, int year = 2021) 
        : title(title), author(author), year(year) {}
    void display() const {
        std::cout << "Title: " << title << ", Author: " << author << ", Year: " << year << std::endl;
    }
};

3. 成员函数的重载

类的成员函数可以重载，即允许函数名相同但参数列表不同的多个函数存在。


class Calculator {
public:
    int add(int a, int b) {
        return a + b;
    }
    double add(double a, double b) {
        return a + b;
    }
};

四、静态成员的应用方法

静态成员是类的成员，但它们不属于类的任何对象。以下是一些静态成员的应用方法：

1. 静态数据成员

静态数据成员属于类，而不是对象。它们在类的所有对象之间共享。


class Counter {
private:
    static int count;
public:
    Counter() {
        count++;
    }
    static int getCount() {
        return count;
    }
};
int Counter::count = 0;  // 初始化静态数据成员

2. 静态成员函数

静态成员函数没有this指针，它们可以直接访问静态数据成员，但不能直接访问非静态数据成员。


class MathUtils {
private:
    static double pi;
public:
    static double getPi() {
        return pi;
    }
};
double MathUtils::pi = 3.14159;  // 初始化静态数据成员

五、友元函数和友元类的应用方法

友元函数和友元类可以访问类的私有和保护成员，它们提供了一种打破封装的方法。以下是一些友元函数和友元类的应用方法：

1. 友元函数

友元函数是在类外部定义的函数，通过在类声明中使用friend关键字声明，可以访问该类的私有和保护成员。


class Box {
private:
    double width;
public:
    Box(double w) : width(w) {}
    friend void printWidth(const Box& b);
};
void printWidth(const Box& b) {
    std::cout << "Width of box: " << b.width << std::endl;
}

2. 友元类

友元类是在类外部定义的类，通过在类声明中使用friend关键字声明，可以访问该类的私有和保护成员。


class Box;
class Printer;
class Box {
private:
    double width;
public:
    Box(double w) : width(w) {}
    friend class Printer;
};
class Printer {
public:
    void printWidth(const Box& b) {
        std::cout << "Width of box: " << b.width << std::endl;
    }
};