【C++漂流记】一文搞懂类与对象中的对象特征

news2025/10/28 18:05:42

在C++中，类与对象是面向对象编程的基本概念。类是一种抽象的数据类型，用于描述对象的属性和行为。而对象则是类的实例，具体化了类的属性和行为。本文将介绍C++中类与对象的对象特征，并重点讨论了对象的引用。
在这里插入图片描述

文章目录

  • 一、构造函数和析构函数
  • 二、函数的分类和调用
    • 1. 分类
    • 2. 调用方式
    • 3. 示例代码
    • 4. 输出结果：
    • 5. 代码解释
  • 三、拷贝构造函数的时机
  • 四、构造函数调用规则
  • 五、深拷贝和浅拷贝
  • 六、初始化列表
  • 七、类对象作为类成员
  • 八、静态成员

相关链接：
一文搞懂类与对象的封装
一文搞懂C++中的引用
函数的高级应用

一、构造函数和析构函数

当我们创建一个类时，它可能具有一些成员变量和成员函数。构造函数和析构函数是类的特殊成员函数，用于初始化对象和清理对象。

  1. 构造函数的作用是在创建对象时初始化对象的成员变量。它的名称与类名相同，没有返回类型，并且可以有参数。构造函数可以有多个重载版本，根据传入的参数的类型和数量来确定使用哪个构造函数。构造函数在对象创建时自动调用。

  2. 析构函数的作用是在对象销毁时清理对象的资源。它的名称与类名相同，前面加上一个波浪号（~），没有返回类型，并且不接受任何参数。析构函数只能有一个，不能重载。析构函数在对象销毁时自动调用。

示例代码：

class Person {
public:
    string name;
    int age;

    // 默认构造函数
    Person() {
        name = "Unknown";
        age = 0;
        cout << "Default constructor called" << endl;
    }

    // 带参数的构造函数
    Person(string n, int a) {
        name = n;
        age = a;
        cout << "Parameterized constructor called" << endl;
    }

    // 析构函数
    ~Person() {
        cout << "Destructor called" << endl;
    }
};

int main() {
    // 使用默认构造函数创建对象
    Person p1;
    cout << "Name: " << p1.name << ", Age: " << p1.age << endl;

    // 使用带参数的构造函数创建对象
    Person p2("John", 25);
    cout << "Name: " << p2.name << ", Age: " << p2.age << endl;

    return 0;
}

输出结果：

Default constructor called
Name: Unknown, Age: 0
Parameterized constructor called
Name: John, Age: 25
Destructor called
Destructor called

代码解释：
在上述示例中，我们定义了一个名为Person的类，它具有两个成员变量：name和age。我们使用构造函数和析构函数来初始化和清理这些成员变量。

首先，我们定义了一个默认构造函数，它没有参数。在默认构造函数中，我们将name设置为Unknown，将age设置为0，并打印一条消息来表示构造函数被调用。

接下来，我们定义了一个带参数的构造函数，它接受一个字符串参数和一个整数参数。在带参数的构造函数中，我们将传入的参数值分别赋给name和age成员变量，并打印一条消息来表示构造函数被调用。

在主函数中，我们首先使用默认构造函数创建一个名为p1的对象。由于没有传入任何参数，因此默认构造函数被调用。然后，我们打印出p1对象的name和age成员变量的值，它们分别为Unknown和0。

接下来，我们使用带参数的构造函数创建一个名为p2的对象。我们传入字符串"John"和整数25作为参数，因此带参数的构造函数被调用。然后，我们打印出p2对象的name和age成员变量的值，它们分别为John和25。

在程序结束时，对象p1和p2超出了它们的作用域，因此它们被销毁。在对象销毁的过程中，析构函数被自动调用。在示例中，我们在析构函数中打印了一条消息来表示析构函数被调用。

二、函数的分类和调用

1. 分类

  1. 默认构造函数：如果类没有显式定义构造函数，则编译器会自动生成一个默认构造函数。默认构造函数没有参数，也不执行任何初始化操作。它在创建对象时被隐式调用。

  2. 带参数的构造函数：带参数的构造函数接受一个或多个参数，并用这些参数来初始化对象的成员变量。它们在对象创建时被调用，并且根据传入的参数的类型和数量来确定使用哪个构造函数。

  3. 拷贝构造函数：拷贝构造函数是一种特殊的构造函数，它接受一个同类对象的引用作为参数，并使用该对象的值来初始化新创建的对象。拷贝构造函数在以下情况下被调用：

    • 使用一个对象初始化另一个对象时
    • 将对象作为函数参数传递给函数
    • 从函数返回对象

2. 调用方式

  1. 直接调用：可以通过类名加括号的方式直接调用构造函数。例如：MyClass obj(10);

  2. 隐式调用：构造函数在创建对象时隐式调用。例如：MyClass obj = MyClass(10);，这里会调用带参数的构造函数来创建对象。

  3. 拷贝初始化：使用一个对象初始化另一个对象时，会调用拷贝构造函数。例如：MyClass obj1(10); MyClass obj2 = obj1;

  4. 函数参数传递：将对象作为函数参数传递给函数时，会调用拷贝构造函数。例如：void func(MyClass obj);，在调用函数func(obj)时会调用拷贝构造函数。

  5. 函数返回对象：从函数返回对象时，会调用拷贝构造函数。例如：MyClass func() { return MyClass(10); }

3. 示例代码

#include <iostream>
using namespace std;

class MyClass {
public:
    int num;

    // 默认构造函数
    MyClass() {
        num = 0;
        cout << "Default constructor called" << endl;
    }

    // 带参数的构造函数
    MyClass(int n) {
        num = n;
        cout << "Parameterized constructor called" << endl;
    }

    // 拷贝构造函数
    MyClass(const MyClass& obj) {
        num = obj.num;
        cout << "Copy constructor called" << endl;
    }

    // 析构函数
    ~MyClass() {
        cout << "Destructor called" << endl;
    }
};

int main() {
    // 直接调用构造函数
    MyClass obj1(10);

    // 隐式调用构造函数
    MyClass obj2 = MyClass(20);

    // 拷贝初始化
    MyClass obj3(obj1);

    // 函数参数传递
    void func(MyClass obj);
    func(obj1);

    // 函数返回对象
    MyClass func();
    MyClass obj4 = func();

    return 0;
}

4. 输出结果：

Parameterized constructor called
Parameterized constructor called
Copy constructor called
Copy constructor called
Destructor called
Destructor called
Destructor called
Destructor called

5. 代码解释

在上述示例中，我们定义了一个名为MyClass的类，它包含一个成员变量num和多个构造函数。我们创建了多个对象，并通过不同的方式调用构造函数。

首先，我们通过直接调用构造函数创建了对象obj1，它会调用带参数的构造函数。然后，我们通过隐式调用构造函数创建了对象obj2，它也会调用带参数的构造函数。

接下来，我们通过拷贝初始化创建了对象obj3，它使用对象obj1的值来初始化。在拷贝初始化过程中，会调用拷贝构造函数。

然后，我们定义了一个函数func，它接受一个MyClass对象作为参数。在调用函数func(obj1)时，会调用拷贝构造函数来将对象obj1传递给函数。

最后，我们定义了一个函数func，它返回一个MyClass对象。在调用函数func()并将返回的对象赋值给obj4时，会调用拷贝构造函数。

在程序结束时，所有对象超出了它们的作用域，因此它们被销毁。在对象销毁的过程中，析构函数被自动调用。在示例中，我们在析构函数中打印了一条消息来表示析构函数被调用。

三、拷贝构造函数的时机

  1. 使用一个对象初始化另一个对象时：当使用一个已经存在的对象来初始化一个新对象时，会调用拷贝构造函数。例如：
class MyClass {
public:
    MyClass(int value) : m_value(value) {}
    MyClass(const MyClass& other) : m_value(other.m_value) {
        std::cout << "Copy constructor called" << std::endl;
    }
private:
    int m_value;
};

MyClass obj1(10);
MyClass obj2 = obj1; // 调用拷贝构造函数
  1. 将对象作为函数参数传递给函数：当将对象作为函数参数传递给函数时，会调用拷贝构造函数。例如：
class MyClass {
public:
    MyClass(int value) : m_value(value) {}
    MyClass(const MyClass& other) : m_value(other.m_value) {
        std::cout << "Copy constructor called" << std::endl;
    }
private:
    int m_value;
};

void func(MyClass obj) {
    // Do something with obj
}

MyClass obj1(10);
func(obj1); // 调用拷贝构造函数
  1. 从函数返回对象：当从函数返回对象时，会调用拷贝构造函数。例如：
class MyClass {
public:
    MyClass(int value) : m_value(value) {}
    MyClass(const MyClass& other) : m_value(other.m_value) {
        std::cout << "Copy constructor called" << std::endl;
    }
private:
    int m_value;
};

MyClass func() {
    MyClass obj(10);
    return obj; // 调用拷贝构造函数
}
  1. 在使用类对象进行赋值操作时，也会调用拷贝构造函数。例如：
class MyClass {
public:
    MyClass(int value) : m_value(value) {}
    MyClass(const MyClass& other) : m_value(other.m_value) {
        std::cout << "Copy constructor called" << std::endl;
    }
private:
    int m_value;
};

MyClass obj1(10);
MyClass obj2;
obj2 = obj1; // 调用拷贝构造函数

需要注意的是，编译器有时会进行优化，避免不必要的拷贝构造函数的调用。这种优化称为“拷贝消除”（copy elision）。在某些情况下，编译器可能会直接将对象的值从一个位置移动到另一个位置，而不是进行拷贝构造函数的调用。这可以提高性能，但是不会调用拷贝构造函数。

四、构造函数调用规则

构造函数调用规则如下：

  1. 默认构造函数：如果没有显式定义构造函数，编译器会自动生成一个默认构造函数。默认构造函数没有参数，并且执行默认的初始化操作。当创建对象时，如果没有提供参数，会调用默认构造函数。

  2. 参数化构造函数：参数化构造函数接受一个或多个参数，并用这些参数来初始化对象的成员变量。当创建对象时，如果提供了参数，会调用对应的参数化构造函数。

  3. 拷贝构造函数：拷贝构造函数接受一个同类型的对象作为参数，并使用该对象的值来初始化新对象。拷贝构造函数可以用于对象的拷贝初始化、函数参数传递和函数返回对象等场景。

  4. 移动构造函数：移动构造函数是C++11引入的新特性，它接受一个右值引用作为参数，并使用该参数的值来初始化新对象。移动构造函数通常用于在对象的资源所有权转移时提高性能。

构造函数的调用规则如下：

  • 当创建对象时，会根据提供的参数类型和数量来选择合适的构造函数进行调用。如果没有提供参数，则会调用默认构造函数。
  • 当使用一个对象来初始化另一个对象时，会调用拷贝构造函数。
  • 当将对象作为函数参数传递给函数时，会调用拷贝构造函数。
  • 当从函数返回对象时，会调用拷贝构造函数。
  • 在使用类对象进行赋值操作时，也会调用拷贝构造函数。
  • 在某些情况下，编译器会进行优化，避免不必要的拷贝构造函数的调用。这种优化称为“拷贝消除”（copy elision）。

五、深拷贝和浅拷贝

浅拷贝是指将一个对象的值复制到另一个对象，包括对象的成员变量。这意味着两个对象共享相同的内存地址，对其中一个对象的修改会影响到另一个对象。浅拷贝只复制了对象的表面层次，没有复制对象所拥有的资源。

深拷贝是指将一个对象的值复制到另一个对象，并且为新对象分配独立的内存空间。这样两个对象就拥有了彼此独立的内存空间，对其中一个对象的修改不会影响到另一个对象。深拷贝会递归地复制对象的所有成员变量，包括对象所拥有的资源。

示例代码：

#include <iostream>
#include <cstring>

class Person {
public:
    Person(const char* name, int age) {
        m_name = new char[strlen(name) + 1];
        strcpy(m_name, name);
        m_age = age;
    }
    
    // 拷贝构造函数
    Person(const Person& other) {
        m_name = new char[strlen(other.m_name) + 1];
        strcpy(m_name, other.m_name);
        m_age = other.m_age;
    }
    
    // 析构函数
    ~Person() {
        delete[] m_name;
    }
    
    // 打印信息
    void printInfo() {
        std::cout << "Name: " << m_name << ", Age: " << m_age << std::endl;
    }
    
private:
    char* m_name;
    int m_age;
};

int main() {
    Person person1("Alice", 25);
    Person person2 = person1; // 浅拷贝
    person1.printInfo(); // 输出：Name: Alice, Age: 25
    person2.printInfo(); // 输出：Name: Alice, Age: 25
    
    person2.printInfo(); // 输出：Name: Alice, Age: 25
    person2.printInfo(); // 输出：Name: Alice, Age: 25
    
    person1.printInfo(); // 输出：Name: Bob, Age: 30
    person2.printInfo(); // 输出：Name: Alice, Age: 25
    
    return 0;
}

在上面的示例中，我们定义了一个Person类，其中包含一个字符串类型的成员变量m_name和一个整型的成员变量m_age。在构造函数中，我们使用new运算符为m_name分配了独立的内存空间，并将字符串复制到该内存空间中。

然后，我们创建了一个person1对象，并将其值赋给person2对象。由于默认的拷贝构造函数是浅拷贝，所以person2对象的m_name指针指向了与person1对象相同的内存空间。当我们修改person2对象的m_name时，实际上也会修改person1对象的m_name。这就是浅拷贝的特点。

为了实现深拷贝，我们需要自定义拷贝构造函数，并在其中为m_name分配独立的内存空间，并将字符串复制到该空间中。这样，person2对象就拥有了自己独立的m_name内存空间，对其进行修改不会影响到person1对象。

总结起来，浅拷贝只复制对象的表面层次，而深拷贝会递归地复制对象的所有成员变量，包括对象所拥有的资源。深拷贝需要自定义拷贝构造函数来实现。

六、初始化列表

初始化列表是一种在构造函数中初始化成员变量的方法，可以用于实现深拷贝。

在上面的示例中，我们可以使用初始化列表来实现深拷贝，而不需要在拷贝构造函数中手动分配内存和复制字符串。

下面是使用初始化列表实现深拷贝的示例：

#include <iostream>
#include <cstring>

class Person {
public:
    Person(const char* name, int age) : m_age(age) {
        m_name = new char[strlen(name) + 1];
        strcpy(m_name, name);
    }
    
    // 拷贝构造函数
    Person(const Person& other) : m_age(other.m_age) {
        m_name = new char[strlen(other.m_name) + 1];
        strcpy(m_name, other.m_name);
    }
    
    // 析构函数
    ~Person() {
        delete[] m_name;
    }
    
    // 打印信息
    void printInfo() {
        std::cout << "Name: " << m_name << ", Age: " << m_age << std::endl;
    }
    
private:
    char* m_name;
    int m_age;
};

int main() {
    Person person1("Alice", 25);
    Person person2 = person1; // 深拷贝
    person1.printInfo(); // 输出：Name: Alice, Age: 25
    person2.printInfo(); // 输出：Name: Alice, Age: 25
    
    person2.printInfo(); // 输出：Name: Alice, Age: 25
    person2.printInfo(); // 输出：Name: Alice, Age: 25
    
    person1.printInfo(); // 输出：Name: Alice, Age: 25
    person2.printInfo(); // 输出：Name: Alice, Age: 25
    
    return 0;
}

在上面的示例中，我们在构造函数的初始化列表中分配了独立的内存空间，并将字符串复制到该空间中。这样，person2对象就拥有了自己独立的m_name内存空间，对其进行修改不会影响到person1对象。

使用初始化列表可以简化代码，并且可以确保在对象构造时成员变量已经正确初始化。这对于实现深拷贝非常有用。

七、类对象作为类成员

当一个类的成员变量是另一个类的对象时，我们需要在拷贝构造函数中正确地拷贝这些成员变量。

以下是一个示例，其中Person类的一个成员变量是Address类的对象：

#include <iostream>
#include <cstring>

class Address {
public:
    Address(const char* city, const char* street) {
        m_city = new char[strlen(city) + 1];
        strcpy(m_city, city);
        
        m_street = new char[strlen(street) + 1];
        strcpy(m_street, street);
    }
    
    Address(const Address& other) {
        m_city = new char[strlen(other.m_city) + 1];
        strcpy(m_city, other.m_city);
        
        m_street = new char[strlen(other.m_street) + 1];
        strcpy(m_street, other.m_street);
    }
    
    ~Address() {
        delete[] m_city;
        delete[] m_street;
    }
    
    void printInfo() {
        std::cout << "City: " << m_city << ", Street: " << m_street << std::endl;
    }
    
private:
    char* m_city;
    char* m_street;
};

class Person {
public:
    Person(const char* name, int age, const Address& address) : m_age(age), m_address(address) {
        m_name = new char[strlen(name) + 1];
        strcpy(m_name, name);
    }
    
    Person(const Person& other) : m_age(other.m_age), m_address(other.m_address) {
        m_name = new char[strlen(other.m_name) + 1];
        strcpy(m_name, other.m_name);
    }
    
    ~Person() {
        delete[] m_name;
    }
    
    void printInfo() {
        std::cout << "Name: " << m_name << ", Age: " << m_age << std::endl;
        m_address.printInfo();
    }
    
private:
    char* m_name;
    int m_age;
    Address m_address;
};

int main() {
    Address address("New York", "Broadway");
    Person person1("Alice", 25, address);
    Person person2 = person1; // 深拷贝
    person1.printInfo(); // 输出：Name: Alice, Age: 25, City: New York, Street: Broadway
    person2.printInfo(); // 输出：Name: Alice, Age: 25, City: New York, Street: Broadway
    
    return 0;
}

在上面的示例中，Person类的一个成员变量是Address类的对象。在Person类的拷贝构造函数中，我们使用拷贝构造函数来正确地拷贝Address对象。这样，当我们拷贝一个Person对象时，Person对象和其成员变量Address对象都会进行深拷贝。

需要注意的是，在Person类的析构函数中，我们只需要释放m_name成员变量的内存空间，因为m_address成员变量的内存空间会在Address类的析构函数中释放。

总结起来，当一个类的成员变量是另一个类的对象时，我们需要在拷贝构造函数中正确地拷贝这些成员变量，以实现深拷贝。

八、静态成员

静态成员变量是属于类本身而不是类的实例的。因此，在拷贝构造函数中不需要拷贝静态成员变量，因为它们在所有类的实例之间是共享的。

以下是一个示例，其中Person类有一个静态成员变量count：

#include <iostream>

class Person {
public:
    Person(const char* name, int age) : m_age(age) {
        m_name = new char[strlen(name) + 1];
        strcpy(m_name, name);
        count++;
    }
    
    Person(const Person& other) : m_age(other.m_age) {
        m_name = new char[strlen(other.m_name) + 1];
        strcpy(m_name, other.m_name);
        count++;
    }
    
    ~Person() {
        delete[] m_name;
        count--;
    }
    
    static int getCount() {
        return count;
    }
    
private:
    char* m_name;
    int m_age;
    static int count;
};

int Person::count = 0;

int main() {
    Person person1("Alice", 25);
    Person person2 = person1; // 深拷贝
    std::cout << "Count: " << Person::getCount() << std::endl; // 输出：Count: 2
    
    return 0;
}

在上面的示例中，Person类有一个静态成员变量count，用于记录创建的Person对象的数量。在构造函数中，我们通过递增count来跟踪对象的数量，在析构函数中通过递减count来更新对象的数量。

在拷贝构造函数中，我们不需要拷贝静态成员变量count，因为它是属于类本身而不是类的实例。因此，在拷贝构造函数中只需要拷贝非静态成员变量即可。

总结起来，静态成员变量不需要在拷贝构造函数中进行拷贝，因为它们是属于类本身而不是类的实例。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/996421.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

【云原生进阶之PaaS中间件】第二章Zookeeper-1-综述

【云原生进阶之PaaS中间件】第二章Zookeeper-1-综述

1 Zookeeper基础 1.1 简介 ZooKeeper 是一个分布式的&#xff0c;开放源码的分布式应用程序协调服务&#xff0c;它包含一个简单的原语集&#xff0c;分布式应用程序可以基于它实现同步服务&#xff0c;配置维护和命名服务等。 Zookeeper是hadoop的一个子项目&#xff0c;其发…
阅读更多...
职场工作与生活

职场工作与生活

序言&#xff1a; 和很多在CSDN的博主一样&#xff0c;大家在工作之后就很少或者是不再回到CSDN&#xff0c;确实自己也一年多没上了。因为可能当初大家在这就是为了记录和分享当初自己学习技术的东西。而大家走出象牙塔开始工作后&#xff0c;发生了很大的转变。在国内…
阅读更多...
2核2G3M带宽服务器腾讯云和阿里云价格、性能对比

2核2G3M带宽服务器腾讯云和阿里云价格、性能对比

2核2G云服务器可以选择阿里云服务器或腾讯云服务器&#xff0c;腾讯云轻量2核2G3M带宽服务器95元一年&#xff0c;阿里云轻量2核2G3M带宽优惠价108元一年&#xff0c;不只是轻量应用服务器&#xff0c;阿里云还可以选择ECS云服务器u1&#xff0c;腾讯云也可以选择CVM标准型S5云…
阅读更多...
堆相关例子-最大线段重合问题

堆相关例子-最大线段重合问题

问题描述 给定很多线段&#xff0c;每个线段都有两个数[start, end]&#xff0c; 表示线段开始位置和结束位置&#xff0c;左右都是闭区间 规定&#xff1a; 1&#xff09;线段的开始和结束位置一定都是整数值 2&#xff09;线段重合区域的长度必须>1 返回线段最多重合…
阅读更多...
Alibaba(获得店铺的所有商品) API 接口

Alibaba(获得店铺的所有商品) API 接口

为了进行电商平台 的API开发&#xff0c;首先我们需要做下面几件事情。 1&#xff09;开发者注册一个账号 2&#xff09;然后为每个alibaba应用注册一个应用程序键&#xff08;App Key) 。 3&#xff09;下载alibaba API的SDK并掌握基本的API基础知识和调用 4&#xff09;利…
阅读更多...
appium+jenkins实例构建

appium+jenkins实例构建

自动化测试平台 Jenkins简介 是一个开源软件项目&#xff0c;是基于java开发的一种持续集成工具&#xff0c;用于监控持续重复的工作&#xff0c;旨在提供一个开放易用的软件平台&#xff0c;使软件的持续集成变成可能。 前面我们已经开完测试脚本&#xff0c;也使用bat 批处…
阅读更多...
Linux TCP和UDP协议

Linux TCP和UDP协议

目录 TCP协议TCP协议的面向连接1.三次握手2.四次挥手 TCP协议的可靠性1.TCP状态转移——TIME_WAIT 状态TIME_WAIT 状态存在的意义&#xff1a;&#xff08;1&#xff09;可靠的终止TCP连接。&#xff08;2&#xff09;让迟来的TCP报文有足够的时间被识别并被丢弃。 2.应答确认、…
阅读更多...
linux 堆探索

linux 堆探索

堆的虚拟地址是连续的&#xff0c;是brk来分配&#xff0c;brk是一个指针指向堆顶的指针&#xff0c;并且是可以复用的&#xff0c;但是只有在堆顶空闲128k时&#xff0c;才收缩&#xff0c;也就是说&#xff0c;为了减少page_fault&#xff0c;可重用&#xff0c;开销小的特点…
阅读更多...
消息队列--入门篇

消息队列--入门篇

消息队列–入门篇 目录 消息队列--入门篇如何学习一门新技术&#xff1f;消息队列的组件大体介绍一下producerproducer groupnameSrvbrokerbroker clusterconsumer和consumer groupTopicTag 总结 如何学习一门新技术&#xff1f; 学习任何知识需要有一个整体的认识&#xff0c…
阅读更多...
【数据分享】2006-2021年我国省份级别的园林绿化相关指标（多项指标）

【数据分享】2006-2021年我国省份级别的园林绿化相关指标（多项指标）

《中国城市建设统计年鉴》中细致地统计了我国城市市政公用设施建设与发展情况&#xff0c;在之前的文章中&#xff0c;我们分享过基于2006-2021年《中国城市建设统计年鉴》整理的2006—2021年我国省份级别的市政设施水平相关指标、2006-2021年我国省份级别的各类建设用地面积数…
阅读更多...
【Linux】进程概念I --操作系统概念与冯诺依曼体系结构

【Linux】进程概念I --操作系统概念与冯诺依曼体系结构

Halo&#xff0c;这里是Ppeua。平时主要更新C语言&#xff0c;C&#xff0c;数据结构算法…感兴趣就关注我吧&#xff01;你定不会失望。 本篇导航 1. 冯诺依曼体系结构为什么这样设计? 2. 操作系统概念为什么我们需要操作系统呢?操作系统怎么进行管理? 计算机是由两部分组…
阅读更多...
使用Xshell远程访问工具连接到Linux

使用Xshell远程访问工具连接到Linux

首先需要查看Linux地址&#xff0c;在Linux主界面中右键选择“Open in Terminal” 输入“ifconfig”指令查看IP地址 打开Xshell&#xff0c;输入相关信息&#xff0c;建立连接 点击连接&#xff0c;按照提示输入用户名 root和你自己安装centos7时设置的密码&#xff0c;用…
阅读更多...
css实现圆角三角形，圆角三角形的实现

css实现圆角三角形，圆角三角形的实现

今天给大家带来一个如何实现圆角三角形的方案&#xff0c;这个方案虽然可以实现&#xff0c;但是也是借助拼凑等方式来实现的&#xff0c;假如想一个div来实现圆角三角形&#xff0c;还是比较困难的。之前文章讲了如何实现对话框&#xff0c;里面介绍了三角形的实现方式。今天讲…
阅读更多...
使用navicat for mongodb连接mongodb

使用navicat for mongodb连接mongodb

使用navicat for mongodb连接mongodb 安装navicat for mongodb连接mongodb 安装navicat for mongodb 上文mongodb7.0安装全过程详解我们说过&#xff0c;在安装的时候并没有勾选install mongodb compass 我们使用navicat去进行可视化的数据库管理 navicat for mongodb下载地址…
阅读更多...
秒杀“超卖”问题

秒杀“超卖”问题

概述&#xff1a;限时秒杀活动在我们的日常生活中有很多&#xff0c;尤其在“双11”&#xff0c;“618”这类购物节活动中用户的并发数更是海量剧增&#xff0c;那么系统为了防止“超卖”秒杀商品&#xff0c;怎么做才能不影响性能的同时防止超卖。 为了解决“超卖”问题有两种…
阅读更多...
mysql或ps提示 vcruntime140_1.dll丢失如何修复，5种方法办法你搞定

mysql或ps提示 vcruntime140_1.dll丢失如何修复，5种方法办法你搞定

今天我在运行一款新安装的软件时&#xff0c;突然遇到了一个让我十分困扰的问题——系统提示vcruntime140_1.dll文件丢失。这个问题导致我无法正常使用这个软件&#xff0c;我也不知道怎么回事&#xff0c;所以我在网上找了一天终于让我找到解决这个问题的方法了&#xff0c;今…
阅读更多...
绩效只是绩效

绩效只是绩效

绩效只是绩效 一、背景二、绩效和管理三、绩效和薪资四、QA环节五、总结与反思 一、背景 目前大部分主体的绩效考核方向不明确&#xff0c;有的只是为了考核而考核&#xff0c;那么绩效是什么&#xff1f; 打A&#xff08;超出预期&#xff09;和打D&#xff08;低于预期&…
阅读更多...
阿里云ESC服务器CPU一直处于100%该如何排查？

阿里云ESC服务器CPU一直处于100%该如何排查？

阿里云ESC服务器CPU一直处于100%该如何排查&#xff1f; 问题背景 使用 docker 容器化部署整个项目&#xff0c;然后服务器的CPU一直处于100%&#xff0c;此时就出现了问题&#xff1a;此时如果重新开启一个窗口去连接&#xff0c;或者访问宝塔面板、Navicat连接MySQL就连接不…
阅读更多...
使用redis+lua通过原子减解决超卖问题【示例】

使用redis+lua通过原子减解决超卖问题【示例】

文章目录 前言一、准备工作二、不使用Lua三、使用Lua 前言 超卖&#xff0c;即在并发的情况下&#xff0c;所售商品数量大于商品的库存数量。在并发量大的情况下&#xff0c;用户请求同时到达&#xff0c;对数据库进行操作&#xff0c;在没有采取相应的处理的情况时从而导致出…
阅读更多...
第八章 Linux实际操作——定时任务调度

第八章 Linux实际操作——定时任务调度

第八章 Linux实际操作——定时任务调度 8.1 crond任务调度8.1.1 概述8.1.2 基本语法8.1.3 常用选项8.1.4 快速入门8.1.5 应用实例8.1.6 crond相关指令 8.2 at定时任务8.2.1基本介绍8.2.2 at命令格式8.2.3 at命令选项8.2.4 at时间定义8.2.5 应用实例 8.1 crond任务调度 crontab…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023