C++类的六个默认成员函数

已于 2023-11-05 22:47:47 修改
阅读量80 收藏 1
点赞数 1
文章标签： c++ 开发语言
于 2023-11-05 22:43:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_77656191/article/details/134210287
版权

目录

1.构造函数

1.1 概念

1.2 特性

1.3 构造函数的初始化规则 

1.4 初始化列表 

1.4.1 语法

1.4.2 规则

1.4.3 注意

2.析构函数

2.1 概念

2.2 特性

3. 拷贝构造函数

3.1 概念

3.2 特性

​编辑

3.3 使用场景

4. 赋值运算符重载

4.1 运算符重载

4.2 赋值运算符重载

4.2.1 赋值运算符重载格式

4.2.2 注意事项

5. 两个取地址运算符重载

5.1 const成员函数

5.1.1 成员函数的定义原则

5.2 取地址和const取地址运算符重载

5.2.1 概念

5.2.2 对象调用两个取地址重载的规则

C++的类中有六个默认的成员函数，分别有各自不同的功能，用户可以显式定义，当用户没有显示定义时，编译器会默认生成。

1.构造函数

1.1 概念

class Date
{
public:
	void Init(int year, int month, int day)
    {
       	_year = year;
	    _month = month;
	    _day = day;
    }

private:
	int _year;
	int _month;
	int _day;
};

int main()
{
    Date dt;
	dt.Init(2023, 10, 18);

	return 0;
}

        在C语言中，在定义一个结构时，总是会给它定义一个Init函数，使用时手动调用进行初始化；这未免有些麻烦，于是C++就引入了构造函数，用来在对象创建的时候由编译器自动调用对成员进行初始化，并且在对象的生命周期内只调用一次。

1.2 特性

1. 函数名与类名相同。
2. 无返回值。
3. 对象实例化时编译器自动调用对应的构造函数。
4. 构造函数可以重载。
5. 当用户没有定义构造函数时，编译器会生成默认的构造函数，用户显式定义则不会生成。

  class Date
 {
  public:
      // 1.无参构造函数
      Date()
     {}
  
      // 2.带参构造函数
      Date(int year, int month, int day)
     {
          _year = year;
          _month = month;
          _day = day;
     }
  private:
      int _year;
      int _month;
      int _day;
 };
  
  void TestDate()
 {
      Date d1; // 调用无参构造函数
      Date d2(2015, 1, 1); // 调用带参的构造函数

      // 注意：如果通过无参构造函数创建对象时，对象后面不用跟括号，否则就成了函数声明
      // 以下代码的函数：声明了d3函数，该函数无参，返回一个日期类型的对象
      // warning C4930: “Date d3(void)”: 未调用原型函数(是否是有意用变量定义的?)
      Date d3();
 }

1.3 构造函数的初始化规则 

        对于接下来说的默认构造函数，不仅仅只是编译器生成的默认构造函数：编译器生成的默认构造函数、无参的构造函数、全缺省的构造函数，这种无需传参的构造函数，都属于默认构造函数；且三个只能存在一个。 

        对于内置类型成员，可以在函数体中初始化；而自定义类型成员，不能在函数体中初始化，具体在哪后文会介绍。

        编译器生成的默认构造函数 在对象创建时同样会自动调用，它对于内置类型成员不做处理，默认是随机值，对于自定义类型成员会去调用它的默认构造。

我们来看下面这段代码的调试结果：

class Stack
{
public:
	Stack(int capacity = 3)
	{
		_a = (int*)malloc(sizeof(int) * capacity);
		_top = 0;
		_capacity = capacity;
	}
	//~Stack()
	//{
	//	cout << "~Stack" << endl;
	//	free(_a);
	//	_top = _capacity = 0;
	//}

private:
	int* _a;
	int _top;
	int _capacity;
};

class MyQueue
{
	Stack pushst;
	Stack popst;
	int size;
};

int main()
{
	MyQueue mq;

	return 0;
}

看到这里大家不免有些疑问，不是说内置类型成员不做处理，默认是随机值吗？那为什么这里size的结果是0 。原因是因为有些新版编译器对这些细节处可能会有个性化的优化，不同的编译器会有不同的结果，所以建议大家还是根据标准来记忆。如，旧版的VS2013就是根据规矩来办事的。 

注意：C++11针对内置成员不初始化的缺陷，设置了补丁：内置类型成员在类声明时可以给默认值（缺省值）。如编译器生成的默认构造在有缺省值时用缺省值初始化，没有才默认是随机值。

1.4 初始化列表 

我们有时会遇到这样几个问题：

1.有些成员变量必须在定义的时候初始化，它们不接受定义后的赋值，如：引用成员变量、const修饰的成员变量；
2.自定义类型成员没有默认构造时，如何初始化；
3.自定义类型成员不想用自己构造函数参数的缺省值初始化时，如何指定初始化。

为了解决这些问题，C++规定，对象的成员变量在构造函数的初始化列表中定义，并且在定义的同时可以指定初始化。

1.4.1 语法

        以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个"成员变量"后面跟
一个放在括号中的初始值或表达式。

class A
{
public:
    //无默认构造
	A(int n， int m)
	{
		_n = n;
        _m = m;
	}
private:
	int _n;
    int _m;
};

class Date
{
public:
	Date(int year, int month, int day)
		: _year(year)
		, _month(month)
		, _day(day)
        //定义的同时初始化
		, ref(_year)
		, a(2)
		, aa(3, 5)
	{}
private:
	int _year;
	int _month;
	int _day;
	int& ref;
	const int a;
	A aa;
};
1.4.2 规则

1.显式写在初始化列表中的成员，内置类型用括号中的值初始化，自定义类型用括号内的数据做参数调用它的构造（前提是参数要匹配）。

2.未显式写在初始化列表中的成员，也会被定义，内置类型有缺省值用缺省值，没有默认是随机值；自定义类型有缺省值用缺省值作参数去调用它自己的构造函数（前提是参数要匹配），没有再调用它的默认构造。

class A
{
public:
	A(int n, int m)
	{
		_n = n;
		_m = m;
	}
private:
	int _n;
	int _m;
};
class Date
{
public:
	Date()
	: ref(_year)
	, a(2)
	{}
private:
	int _year = 1949;
	int _month = 10;
	int _day = 1;
	A aa = { 3,6 };

	int& ref;
	const int a;
};

int main()
{
	Date d;
	return 0;
}

调试结果：

        C++11打的补丁，给缺省值这一操作，本质上其实是将缺省值给了初始化列表；对于自定义类型成员声明时给缺省值，叫列表初始化， 使用前提是：要和其自定义类型成员的构造函数的参数相匹配。

1.4.3 注意

1.每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)。

2.类中包含以下成员，必须放在初始化列表位置进行初始化：

  • 引用成员变量
  • const成员变量
  • 自定义类型成员(且该类没有默认构造函数时)

3.尽量使用初始化列表初始化，因为不管你是否使用初始化列表，对于自定义类型成员变量，一定会先使用初始化列表初始化。

4.成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后次序无关。

5.有时候不能只用初始化列表初始化，在一些需要检查或初始化空间时，要用函数体搭配初始化列表完成。

class Stack
{
public:
    Stack(int n = 2)
        //初始化
        :_a((int*)malloc(sizeof(int)*n))
        ,_top(0)
        ,_capacity(n)
    {
        //检查
        if (_a == nullptr)
        {
            perror("malloc fail");
            exit(-1);
        }
        //对空间赋值
        memset(_a, 0, sizeof(int) * n);
    }

private：
    int* _a;
    int _top;
    int _capacity;
};

2.析构函数

2.1 概念

        C语言中对于一个动态开辟的结构，通常自定义Destroy函数对其进行销毁，同样也要自己调用，有时候可能还会忘记，为此C++中就设计了析构函数。

析构函数：与构造函数功能相反，析构函数不是完成对对象本身的销毁，局部对象销毁工作是由
编译器完成的。而对象在销毁时会自动调用析构函数，完成对象中资源的清理工作。

2.2 特性

析构函数是特殊的成员函数，其特征如下：

1. 析构函数名是在类名前加上字符 ~。
2. 无参数无返回值类型。
3. 一个类只能有一个析构函数。注意：析构函数无参数，不能重载。
4. 对象生命周期结束时，C++编译系统系统自动调用析构函数。

5.若未显式定义，系统会自动生成默认的析构函数。编译器生成的默认析构函数，对自定类型成员调用它的析构函数。

class Stack
{
public:
	Stack(int capacity = 3)
	{
		_a = (int*)malloc(sizeof(int) * capacity);
		if (_a == nullptr)
		{
			perror("Stack::malloc failed");
			exit(-1);
		}
		_top = 0;
		_capacity = capacity;
	}

	~Stack()
	{
		free(_a);
		_top = _capacity = 0;
	}

private:
	int* _a;
	int _top;
	int _capacity;
};

class MyQueue
{
	Stack pushst;
	Stack popst;
	int size;
};

int main()
{
	MyQueue mq;

	return 0;
}

6.如果类中没有申请资源时，析构函数可以不写，直接使用编译器生成的默认析构函数，比如Date类；有资源申请时，一定要写，否则会造成资源泄漏，比如Stack类。

class Date
{
public:
	Date(int year = 2, int month = 3, int day = 4)
		: _year(year)
        ，_month(month)
		, _day(day)
    {}
private:
	int _year;
	int _month;
	int _day;
};

3. 拷贝构造函数

3.1 概念

来看这段代码的运行结果

class Stack
{
public:
	Stack(int capacity = 3)
	{
		_a = (int*)malloc(sizeof(int) * capacity);
		if (_a == nullptr)
		{
			perror("Stack::malloc failed");
			exit(-1);
		}
		_top = 0;
		_capacity = capacity;
	}

	~Stack()
	{
		free(_a);
		_top = _capacity = 0;
	}
	
private:
	int* _a;
	int _top;
	int _capacity;
};

void func(Stack stt)
{ }

int main()
{
	Stack st;
	func(st);
}

程序运行崩溃了，其原因是：在调用func函数进行传参时，形参是实参的临时拷贝，默认进行的是值拷贝(浅拷贝)，此时形参和实参的指针成员同时指向同一块内存空间，当函数结束形参stt调用析构正常销毁，但是main函数结束时，st也要调用析构销毁，相当于对同一块内存空间释放两次。

为了解决这个问题，就要进行深拷贝，使形参和实参不能指向同一块空间，C++规定，当用一个已经存在的对象去拷贝初始化另一个要创建的同类对象时，编译器会自动调用一个函数，这个函数就是拷贝构造函数。 

3.2 特性

拷贝构造函数也是特殊的成员函数，其特征如下：

1. 拷贝构造函数是构造函数的一个重载形式。

2. 拷贝构造函数的参数只有一个且必须是类类型对象的引用，使用传值方式编译器直接报错，因为会引发无穷递归调用。

class Date
{
public:
     Date(int year = 1900, int month = 1, int day = 1)
     {
         _year = year;
         _month = month;
         _day = day;
     }

     //Date(const Date d)   // 错误写法：编译报错，会引发无穷递归
    Date(const Date& d)   // 正确写法
    {
        _year = d._year;
        _month = d._month;
        _day = d._day;
    }
private:
     int _year;
     int _month;
     int _day;
};

int main()
{
    Date d1;
    Date d2(d1);
    return 0;
}

d2创建时要拷贝d1，调用d2的拷贝构造进行传参，传值参又要生成拷贝，又要去调用拷贝构造……就这样一直循环调用下去。 

3. 若未显式定义，编译器会生成默认的拷贝构造函数。默认的拷贝构造函数对内置类型成员进行值拷贝(浅拷贝)，对自定义类型成员去调用它的拷贝构造函数。

class Stack
{
public:
	Stack(int capacity = 3)
	{
		_a = (int*)malloc(sizeof(int) * capacity);
		if (_a == nullptr)
		{
			perror("Stack::malloc failed\n");
			exit(-1);
		}
		_top = 0;
		_capacity = capacity;
	}

	Stack(const Stack& st1)
	{
		_a = (int*)malloc(sizeof(int) * st1._capacity);
		if (_a == nullptr)
		{
			perror("Stack::malloc failed\n");
			exit(-1);
		}
		_top = st1._top;
		_capacity = st1._capacity;
	}

	~Stack()
	{
		free(_a);
		_top = _capacity = 0;
	}
	
private:
	int* _a;
	int _top;
	int _capacity;
};

class MyQueue
{
	Stack pushst;
	Stack popst;
	int size = 5;
};

int main()
{
	MyQueue mq1;
	MyQueue mq2(mq1);

	return 0;
}

4. 类中如果有指针成员指向动态申请的内存空间时，一定要自定义拷贝构造函数进行深拷贝，一般链表，栈，队列等类都要显示自定义；而像日期类这种对象，可以直接用编译器生成的默认拷贝构造进行值拷贝。 

3.3 使用场景

拷贝构造函数的经典调用场景

  • 使用已存在的对象创建新对象
  • 函数传值传参时的拷贝
  • 函数返回时的值拷贝

4. 赋值运算符重载

4.1 运算符重载

        内置类型的变量可以直接使用各种运算符，它们在编译期间被转换为各种指令，而自定义类型的对象无法直接使用各种运算符，原因是自定义类型是自己定义的，编译器无法知道使用该运算符要实现什么功能。

所以为了让自定义类型能直接使用一些运算符，用户必须自定义函数来制定重载后的运算符的功能，这一过程就叫运算符重载。

运算符重载是具有特殊函数名的函数，也具有其返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。
函数名字为：关键字operator后面接需要重载的运算符符号。

函数原型：返回值类型 operator运算符(参数列表)

注意：

  1. 重载的运算符必须是原来就有的，不能通过连接其他符号来创建新的操作符：比如operator@
  2. 重载操作符必须有一个类类型参数
  3. 用于内置类型的运算符，其含义不能改变，例如：内置的整型 + ，不 能改变其含义
  4. 作为类成员函数重载时，其形参看起来比操作数数目少1，因为成员函数的第一个参数为隐藏的this
  5. .*   ::   sizeof   ? :   .   注意以上5个运算符不能重载。

例：重载一个日期类的==运算符，用来判断日期是否相等。

1、重载在全局，这时需要成员变量时公有的，那么这样就破坏了封装。

class Date
{
public:
    Date(int year, int month, int day)
    {
    	_year = year;
    	_month = month;
	    _day = day;
    }
//private:
	int _year;
	int _month;
	int _day;
};

bool operator==(const Date& d1, const Date& d2)
{
	return d1._year == d2._year && d1._month == d2._month && d1._day == d2._day;
}

int main()
{
	Date d1(1945, 8, 15);
	Date d2(1949, 10, 1);
	cout << (d1 == d2) << endl; //-> operator==(d1, d2)
	return 0;
}

2、重载在类内，成为类的成员函数，即完成了重载有保证了封装。

class Date
{
public:
    Date(int year, int month, int day)
    {
    	_year = year;
    	_month = month;
	    _day = day;
    }
    // bool operator==(const Date* const this, const Date& d2)
    // 这里需要注意的是，左操作数是this，指向调用函数的对象
    bool operator==(const Date& d) const//这里const是用来限定this指针指向的对象不能被修改
    {
	    return _year == d._year && _month == d._month && _day == d._day;
    }

private:
	int _year;
	int _month;
	int _day;
};


int main()
{
	Date d1(1945, 8, 15);
	Date d2(1949, 10, 1);
	cout << (d1 == d2) << endl; //d1.operator==(d2) -> d1.operator==(&d1, d2)
	return 0;
}

4.2 赋值运算符重载

        对于用一个已经存在的对象去拷贝初始化另一个要创建的同类对象要调用拷贝构造函数，而两个已经存在的对象之间的赋值就要调用另一个成员函数：赋值重载函数。

4.2.1 赋值运算符重载格式
  • 参数类型：const Type& ，传递引用可以提高传参效率
  • 返回值类型：Type& ，返回引用可以提高返回的效率，有返回值目的是为了支持连续赋值
  • 检测是否自己给自己赋值
  • 返回* this ：要复合连续赋值的含义
class Date
{
public:
    Date(int year, int month, int day)
    {
    	_year = year;
    	_month = month;
	    _day = day;
    }

    Date& operator=(const Date& d)
    {
	    if (this != &d)//防止自己给自己赋值
	    {
		    _year = d._year;
		    _month = d._month;
		    _day = d._day;
	    }
	    return (*this);
    }

private:
	int _year;
	int _month;
	int _day;
};
4.2.2 注意事项

1. 用户没有显式实现时，编译器会生成一个默认赋值运算符重载函数，调用时对内置类型成员进行值拷贝，对自定义成员调用它的赋值重载。

2. 赋值运算符只能重载成类的成员函数不能重载成全局函数。

原因：赋值运算符如果不显式实现，编译器会生成一个默认的。此时用户再在类外自己实现一个全局的赋值运算符重载，就和编译器在类中生成的默认赋值运算符重载冲突了，故赋值运算符重载只能是类的成员函数。

3. 和拷贝构造函数类似， 类中如果有指针成员指向动态申请的内存空间时，一定要自定义赋值重载函数进行深拷贝，否则就会出现上面程序运行崩溃的场景。

5. 两个取地址运算符重载

5.1 const成员函数

我们来看一个测试

class Date
{
public:
    Date(int year, int month, int day)
    {
    	_year = year;
    	_month = month;
	    _day = day;
    }
    void Print()
    {
	    printf("const\n");
	    printf("%d-%d-%d\n", _year, _month, _day);
    }

private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d1(1945, 8, 15);
	const Date d2(1949, 10, 1);

	d1.Print();
	d2.Print();
    return 0;
}

这段代码的结果是编译器报错 ，表示d2的类型是const Date，在传参时不能直接把d2的地址传给非const 修饰的this指针，原因也很简单，在调用成员函数时，会将当前对象的地址传给this指针，const修饰的对象只能由const修饰的指针接收，同时const修饰的指针不仅可以接收const修饰的对象，也可以接收非const对象，对象的权限只能被平移或缩小，不能被放大。

为了让const对象也能调用成员函数，我们将成员函数用const修饰

将const修饰的“成员函数”称之为const成员函数，const修饰类成员函数，实际修饰该成员函数隐含的this指针，表明在该成员函数中不能对类的任何成员进行修改。

所以，上面这段代码应该将Print修改成const成员函数


    //void Print(const Date* const this)

    void Print() const
    {
	    printf("const\n");
	    printf("%d-%d-%d\n", _year, _month, _day);
    }
5.1.1 成员函数的定义原则

1.能定义成const成员函数的都应该定义成const成员函数，这样const对象(权限平移)和非const对象(权限缩小)都能调用。

2.要修改成员变量的成员函数不能定义成const成员函数，否则就无法达到修改的目的。

5.2 取地址和const取地址运算符重载

5.2.1 概念

这两个成员函数很简单，就是单纯的对对象取地址，因为是运算符重载，可以直接&对象名调用。当用户未显示定义时，编译器默认生成。

对于日期类，这两个函数的原型

class Date
{
public:
    Date(int year = 1, int month = 1, int day = 1)
    {
    	_year = year;
    	_month = month;
	    _day = day;
    }
    Date* operator&()
	{
		return this;
	}
	const Date* operator&() const
	{
		return this;
	}

private:
	int _year;
	int _month;
	int _day;
};
5.2.2 对象调用两个取地址重载的规则

来看两个测试

一、

class Date
{
public:
	Date(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	Date* operator&()
	{
		return this;
	}
	//const Date* operator&() const
	//{
	//	return this;
	//}

private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d1;
	const Date d2;
	auto pd1 = &d1;
	auto pd2 = &d2;

	std::cout << typeid(pd1).name() << std::endl;
	std::cout << typeid(pd2).name() << std::endl;
	return 0;
}

 我们发现，d2的类型是const Date，不能调用Date类型的成员函数，其调用的是编译器生成默认的成员函数。

二、 

class Date
{
public:
    Date(int year = 1, int month = 1, int day = 1)
    {
    	_year = year;
    	_month = month;
	    _day = day;
    }
    //Date* operator&()
	//{
	//	return this;
	//}
	const Date* operator&() const
	{
		return this;
	}

private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d1;
	const Date d2;
	auto pd1 = &d1;
	auto pd2 = &d2;

	std::cout << typeid(pd1).name() << std::endl;
	std::cout << typeid(pd2).name() << std::endl;
	return 0;
}

结果出来之前，我们会觉得d1会去调用编译器生成的默认成员函数，d1并没有调用默认的Date类型的成员函数，而是直接选择了缩小权限的const Date的成员函数，前面说过，这样其实也是合法的。

规则

1.、两个都显式定义或两个都是默认的时：选参数最合适的。

2、只定义了一个，另一个时默认的时：能用自定义先用自定义的，不能用再用系统默认的。

提醒：上述材料为了方便，将成员函数定义在类中，其实是一种不好的习惯，一般会将声明和定义分开，在类中声明，在类外定义，定义时指定类域。 

阿成688
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
C++类中的特殊成员函数示例详解
01-21
C++类中有几个特殊的非静态成员函数，当用户未定义这些函数时，编译器将给出默认实现。C++11前有四个特殊函数，C++11引入移动语义特性，增加了两个参数为右值的特殊函数。这六个函数分别是： 1、默认构造函数 默认...
对C++默认构造函数的一点重要说明
12-31
造其实是可有可无的，所以不妨说编译器其实是为每个类生成了默认构造函数的。 在深度探索C++对象模型中讲了四种关于编译器自动生成默认构造函数的情况，在这四种情况下生成的默认构 造函数里面是由实质的隐含代码...
C++类成员构造函数和析构函数顺序示例详细讲解
09-04
1. **基类构造函数**：如果一个类是另一个类的派生类，那么在创建派生类对象时，首先会调用基类的默认构造函数。这是为了确保基类的部分能够正确初始化。 2. **非静态数据成员**：接着，按照在类中声明的顺序，初始...
【C++】STL—vector的使用
2301_77112794的博客
09-04 694
本文介绍了vector重点函数接口的使用
【c++23种设计模式概述】
m0_45463480的博客
09-09 359
c++23种设计模式概述。
【C++】vector的简单模拟实现
2303_80828380的博客
09-05 1182
vector的简单模拟实现！！！
C语言——strcpy、sprintf与memcpy
鲸落博客
09-09 691
该函数和printf()函数有很多相似之处，例如printf()将不同类型的数据格式化到终端，而sprintf()函数是将不同类型的数据格式化到字符串中。另外，和strcpy()函数一样，该函数也不会对目标缓冲区进行检查，容易造成溢出。它是一种非常通用的内存复制函数，不仅限于复制字符串，还可以复制任何类型的内存块。3. 未定义行为：程序可能会继续运行，但结果不可预测，可能会输出错误的结果或导致其他未预料的行为。如果memcpy复制字符串，要复制的字节数超过原内存块本身的内存数，会怎么样？
QWidget(c++)嵌入window环境的exe
sunflower_2020的博客
09-05 272
QWidget(c++)嵌入window环境的exe
[ C++ ] 一文复习（基础语法，语言特性，STL回顾）
2301_79175236的博客
09-04 1031
C++复习参考文，待完善
c++ 类的继承详解
HJQD777的博客
09-07 461
继承允许类之间建立层次关系，促进代码重用和扩展。继承有不同的访问控制方式（publicprotectedprivate），影响派生类对基类成员的访问权限。基类的构造函数和析构函数不会被继承，派生类需要自行定义。使用虚函数和多态可以实现灵活的接口设计和动态方法调用。理解继承机制对于设计高效、灵活和可维护的面向对象系统至关重要。
【启明智显技术分享】探讨CAN总线相关知识以及Model3C 2路CAN的应用
ami82的博客
09-05 649
通信错误：由于CAN总线上的节点之间存在不同的优先级，可能导致数据冲突。总线阻塞：在某些情况下，CAN总线上的节点可能会长时间保持发送状态，从而导致其他节点无法发送数据，这种现象被称为总线阻塞。总线干扰：CAN总线可能会受到外部电磁干扰，如电源干扰、射频干扰等，这些干扰可能导致总线上的数据传输出错。总线过载：当CAN总线上的节点数量过多或者通信数据量过大时，可能导致总线过载，从而影响通信性能和稳定性。总线错误：CAN总线上的节点可能会发生硬件故障，例如控制器损坏、接口损坏等，这些情况都可能导致总线错误。
C++位图的实现与详解
2301_80468112的博客
09-09 261
在讲解位图之前我们先来看一道很经典的面试题。给40亿个不重复的无符号整数，没排过序。给一个无符号整数，如何快速判断一个数是否在这40亿个数中。我们有以下两种种解决方法：1. 遍历，时间复杂度O(N)。（太慢）2. 排序(O(NlogN))，利用二分查找: logN。深入分析:解题思路2是否可行，我们先算算40亿个数据大概需要多少内存。
C 标准库 - `＜float.h＞`
wjs2024的博客
09-08 221
float.h>是 C 标准库中的一个头文件，它定义了与浮点数类型相关的宏。这些宏提供了关于浮点数的属性信息，如精度、最小和最大值、以及舍入误差等。这个头文件对于需要精确控制浮点数行为的程序非常有用，尤其是在数值计算和科学计算领域。<float.h>是 C 标准库中一个重要的头文件，它提供了关于浮点数的属性信息，对于需要精确控制浮点数行为的程序非常有用。掌握<float.h>中的宏，可以帮助开发者更好地理解和处理浮点数。
【项目二】C++高性能服务器开发——日志系统(日志器，日志级别，日志事件)
weixin_45962681的博客
09-06 182
其实也没啥。
C++ 标准库的典型内容
最新发布
qq_68194402的博客
09-10 154
C++ 标准库提供了一系列强大且灵活的工具和组件，用于简化程序设计和提高开发效率。它包含多种功能模块，涵盖了内存管理、数据结构、算法、输入输出操作以及类型特征等多个方面
C++之数据类型
QoQ_____________的博客
09-09 191
/宏常量define（注意书写格式）//双精度：double。求数据类型所占空间大小，字节数。//const修饰变量。//单精度：float。
C++ 音频
JackerCSDN的博客
09-09 262
acc流
C语言从头学57——学习头文件locale.h
m0_72128260的博客
09-09 244
头文件中定义了一些宏和函数，涉及程序的本地化设置；这些设置包括：数字格式、货币格式、字符集、日期和时间格式等。
C++深度解析：默认成员函数与运算符重载
默认成员函数是指C++在我们创建类时自动提供的四个函数：构造函数、析构函数、拷贝构造函数和赋值运算符。这些函数在特定情况下自动调用，帮助我们处理对象的生命周期和数据复制。 1. 构造函数：构造函数是一个特殊...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值