彼岸花开C++，类和对象（中）

已于 2024-08-11 15:57:42 修改
阅读量913 收藏 24
点赞数 19
文章标签： c++ 笔记
于 2024-08-11 13:04:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_86606773/article/details/140951520
版权

对类的进一步认识

目录

对类的进一步认识

（1）类的6个默认成员函数

（2）构造函数

（3）析构函数

（4）拷贝构造函数

（5）赋值运算符重载

（6）const成员函数

（7）取地址及const取地址操作符重载

（1）类的6个默认成员函数

一个类中什么成员都没有，简称空类。但空类并不是真的什么都没有。任何类在什么都不写的情况下，编译器会自动生成以下六个默认成员函数。

默认成员函数：用户没有显示实现，编译器会生成的成员函数称为默认成员函数。

class Date {};

（2）构造函数

1.概念：

对于以下Date类：

class Date
{
public:
    void Init(int year,int month,int day)
    {
        _year = year;
        _month = month;
        _day = day;
    }
    void Print()
    {
        cout << _year << "-" << _month << "-" << _day << endl;
    }
private:
    int _year;
    int _month;
    int _day;
};
int main()
{
    Date d1;
    d1.Init(2024,8,5);
    d1.Print();

    Date d2;
    d2.Init(2024,8,6);
    d2.Print();

    return0;
}

对于Date类，可以通过Init公有方法给对象设置日期，能否在对象创建时，就将信息设置进去呢？
构造函数是一个特殊的成员函数，名字与类名相同,创建类类型对象时由编译器自动调用，以保证每个数据成员都有一个合适的初始值，并且在对象整个生命周期内只调用一次。
 

2.特性：

构造函数虽然名称叫构造，但是构造函数的主要任务并不是开空间创建对象，而是初始化对象。


其特征如下：
1.函数名与类名相同。
2.无返回值。
3.对象实例化时编译器自动调用对应的构造函数。
4.构造函数可以重载。(在同一个类中可以定义多个构造函数，这些构造函数有不同的参数列表)
 

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;
};

int main()
{
    Date d1; // 调用无参构造函数
    Date d2(2024,8,6); // 调用带参的构造函数
}

注意：不能写成“Date  d1()”。通过无参构造函数创建对象时，对象后面不用跟括号，否则就成了函数声明。（相当于声明了d1函数，该函数无参，返回一个Date类型的对象。）

如果类中没有显示定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦用户显示定义编译器将不再生成。

class Date
{
public:
    /*
    // 如果用户显式定义了构造函数，编译器将不再生成
    Date(int year, int month, int day)
    {
    _year = year;
    _month = month;
    _day = day;
    }
    */

    void Print()
    {
        cout << _year << "-" << _month << "-" << _day << endl;
    }

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

int main()
{
    // 将Date类中构造函数屏蔽后，代码可以通过编译，因为编译器生成了一个无参的默认构造函数
    // 将Date类中构造函数放开，代码编译失败，因为一旦显式定义任何构造函数，编译器将不再生成
    // 无参构造函数，放开后报错：error C2512: “Date”: 没有合适的默认构造函数可用
    Date d1;
    d1.Print();
    return 0;
}

注：编译器生成默认的构造函数会对自定义类型成员_t调用的它的默认成员函数。

#include <iostream>
using namespace std;

class Time
{
public:
    Time()
    {
        cout << "Time()" << endl;
        _hour = 0;
        _minute = 0;
        _second = 0;
    }
public:
    int _hour;
    int _minute;
    int _second;
};

class Date
{
public:
    // 基本类型（内置类型）
    int _year;
    int _month;
    int _day;

    // 自定义类型
    Time _t;
};

int main()
{
    Date d;
    cout << d._t._hour << ' ' << d._t._minute << ' ' << d._t._second << endl;
    return 0;
}

这里为了方便观察，限定符都置为“public”。

从结果可以看出编译器生成默认的构造函数Date()会对自定类型成员_t调用的它的默认成员
函数，从而完成赋值和打印“Time()”。

注意：无参构造函数，全缺省构造函数，我们没写编译器默认生成的构造函数，都可以认为是默认构造函数。默认构造函数只能有一个。

class Date
{
public:
	// 无参构造函数
	Date()
	{
		_year = 1900;
		_month = 1;
		_day = 1;
	}
	
	// 全缺省构造函数
	Date(int year = 1900,int month = 1,int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
private:
	int _year;
	int _month;
	int _day;
};

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

以上的代码的编译显然是通过不了编译的。无参构造函数和全缺省构造函数同为默认构造函数不能同时存在。

（3）析构函数

1.概念：

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

 2.特性：

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

1.在类名前加上字符‘~’就是析构函数名。

2.无参数无返回值类型。

3.一个类只能有一个析构函数。若未显示定义，系统会自动生成默认的析构函数。

4.析构函数不能重载。

5.对象完成工作时，C++编译系统自动调用析构函数。

注意：如果类中没有申请资源时，析构函数可以不写，直接使用编译器生成的默认析构函数，比如Date类；有资源申请时，一定要写，不然可能造成内存泄漏，比如Stack类。

#include <iostream>
using namespace std;

class Stack
{
public:
	Stack(size_t capacity = 3)
	{
		cout << "Stack()" << endl;
		_array = (int*)malloc(sizeof(int)*capacity);
		if(_array == NULL)
		{
			perror("malloc申请空间失败!!!");
			return;
		}
		
		_capacity = capacity;
		_size = 0;
	}
	
	void Push(int data)
	{
		_array[_size] = data;
		_size++;
	}
	
	~Stack()
	{
		cout << "~Stack()" << endl;
		if(_array)
		{
			free(_array);
			_array = NULL;
			_capacity = 0;
			_size = 0;
		}
	}
private:
	int *_array;
	int _capacity;
	int _size;
};

int main()
{
	Stack S;
	S.Push(1);
	S.Push(2);
	
	return 0;
}

运行结果：

由上面运行结果可以看出对象完成工作结束的时候会自动调用析构函数。

此外，编译器生成的默认析构函数，可以对自定义类型成员调用它的析构函数。

#include <iostream>
using namespace std;

class Time
{
public:
	~Time()
	{
		cout << "~Time()" << endl;
	}
private:
	int _hour;
	int _minute;
	int _second;
};

class Date
{
private:
	// 基本类型(内置类型)
	int _year = 1970;
	int _month = 1;
	int _day = 1;
	
	// 自定义类型
	Time _t;
};

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

运行结果：

说明了Time类的析构函数被调用。

思考：在main()方法中没有直接创建Time类的对象，为什么最后会调用Time类的析构函数？

Answer：main方法中创建了Date对象d，d中的_year,_month,_day三个是内置类型成员，销毁时不需要资源清理，只需要系统直接将其内存回收就行了；_t是Time类对象，在d销毁时，需要将包含的Time类的_t对象销毁，于是就会调用Time类的析构函数。main函数中不能直接调用Time类的析构函数，所以编译器会调用Date类的析构函数，编译器给Date生成了默认的构造函数，然后调用Time类的析构函数，就可以保证每个自定义类型可以被正确的销毁。

（4）拷贝构造函数

1.概念：

拷贝构造函数是C++中的一种特殊的构造函数，用于初始化一个对象为另一个同类对象的副本。其主要用途是在以下情况创建对象时，自动调用拷贝构造函数：

1.通过值传递参数：当一个对象作为参数传递给一个函数时，会创建该对象的副本。

2.返回对象：当一个函数返回一个对象时，也会调用拷贝构造函数。

3.对象的初始化：在一个对象的定义中，用另一个对象进行初始化时，会调用拷贝构造函数。

 2.特性：

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

1.只有单个形参，一般用const修饰。

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

3.拷贝构造函数的参数只有一个且必须是类类型的引用（引用相当于起别名），不引用会引发无穷递归。（调用拷贝构造函数的时候要先传参，而传参就又是一个拷贝构造，从而引起无限套娃。）

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

    // Date d2(d1); --> 调用的就是拷贝构造，但是调用函数时要先传参，传参的过程又是一个拷贝构造的调用
    Date(const Date& d)// 必须用引用（引用相当于起别名），否则会造成无穷递归
    {
        _year = d._year;
        _month = d._month;
        _day = d._day;
    }

    void Print()
    {
        cout << _year << '-' << _month << '-' << _day << endl;
    }
private:
    int _year;
    int _month;
    int _day;
};

int main()
{
    Date d1(2024,8,6);
    // 这两种写法都是拷贝构造
    Date d2(d1);// 拷贝构造
    Date d3 = d1;
    d1.Print();
    d2.Print();
    d3.Print();
    
    return 0;
}

注：在这里补充一个问题：

void func(Date d)
{
    //...
}

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

为什么在上面拷贝构造函数传参的时候会死循环，而这个函数不会。-->>我们调用func，先传参，传参就是一个拷贝构造，然后调用Date类的拷贝构造函数，然后Date类的拷贝构造函数是已经是引用类型的，所以不会造成死循环。

4.若用户未显示定义拷贝构造函数，那么编译器就会生成默认的拷贝构造函数。默认的拷贝构造函数对象按内存存储按字节序完成拷贝，也叫做浅拷贝。

#include <iostream>
using namespace std;

class Time
{
public:
	Time()
	{
		_hour = 1;
		_minute = 1;
		_second = 1;
	}
	
	Time(const Time& d)
	{
		_hour = d._hour;
		_minute = d._minute;
		_second = d._second;
		cout << "Time::Time(const Time&)" << endl;
	}
private:
	int _hour;
	int _minute;
	int _second;
};

class Date
{
private:
	// 基本类型(内置类型)
	int _year = 1970;
	int _month = 1;
	int _day = 1;
	
	// 自定义类型
	Time _t;
};

int main()
{
	Date d1;
	
	// 用存在的d1拷贝d2，此处会调用Date类的拷贝构造函数
	// 但Date类并没有显式定义拷贝构造函数，则编译器会给Date类生成一个默认的拷贝构造函数
	Date d2(d1);
	return 0;
}

运行结果：

运行结果说明了Time类的拷贝构造函数被调用。（在编译器生成的默认拷贝构造函数中，内置类型是按照字节方式直接拷贝的，而自定义类型是调用其拷贝构造函数完成拷贝的。）

注：深拷贝与浅拷贝：

1.浅拷贝：直接复制对象的所有成员（默认行为）。如果对象中包含指向动态内存分配的指针，这可能会导致多个对象指向同一内存地址，造成数据损坏或内存泄漏。

2.深拷贝：复制对象时，为每个指针分配新的内存并拷贝内容，确保各个对象独立拥有自己的数据。（在需要管理动态资源的类中，通常自定义拷贝构造函数，以实现深拷贝。）

（5）赋值运算符重载

1.运算符重载

运算符重载是具有特殊函数名的函数，也具有其返回类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。

函数名字：关键字operator后面接需要重载的运算符号。

函数原型：返回值类型operator操作符(参数列表)。

注意：

  • 不能通过连接其他符号来创建新的操作符：比如operator@
  • 重载操作符必须有一个类类型参数
  • 用于内置类型的运算符，其含义不能改变，比如：内置的整型+，不能改变其含义。
  • 作为类成员函数重载时，其形参看起来比操作数数目少一，因为成员函数的第一个参数为隐藏的this指针
  • “ .* ”，“ :: ”，“ sizeof ”，“ ?: ”，“ . ”   这五个运算符不能重载。

对于一个Date类：

class Date
{
public:
	Date(int year = 1900,int month = 1,int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	
private:
	// 基本类型(内置类型)
	int _year = 1970;
	int _month = 1;
	int _day = 1;
	
	// 自定义类型
	Time _t;
};

我们知道我们可以比较内置类型（int，float....）的数据大小，那么如果我们想比较日期的大小时，编译器会报错。这时我们就要对操作符进行重载。

// 全局的operator==
class Date
{
public:
	Date(int year = 1900,int month = 1,int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	
private:
	// 基本类型(内置类型)
	int _year = 1970;
	int _month = 1;
	int _day = 1;
};

// 运算符有几个操作数，operator重载的函数就有几个参数
bool operator==(const Date& d1,const Date& d2)
{
    return d1._year == d2._year
            && d1._day == d2._day
            && d1._month == d2._month;
}

我们把运算符重载写到全局里，会发现d1和d2的成员变量为private，全局里无法访问，还需要把private改成public。所以我们干脆就直接把运算符重载写成类的成员函数。

#include <iostream>
using namespace std;

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

    Date(const Date& d)
    {
        _year = d._year;
        _month = d._month;
        _day = d._day;
    }

    void Print()
    {
        cout << _year << '-' << _month << '-' << _day << endl;
    }

    // d1 == d2
    // d1.operator==(&d1,d2);
    bool operator==(const Date& d)
    {
        return this->_year == d._year
            && _month == d._month
            && _day == d._day;
    }
    
private:
    int _year;
    int _month;
    int _day;
};

这里写成成员函数时，我们可以明显的看到参数只有一个，但实际上还有一个隐藏的this指针，且为第一个参数。（bool operator==(Date* this,const Date& d)  // 不用我们显式写出）

接下来我们实现一个稍微完整的日期类：

#include <iostream>
using namespace std;

// 实现一个完整的日期类
class Date
{
public:
    int GetMonthDay(int year,int month)
    {
        static int monthDays[13] = {0,31,28,31,30,31,30,31,31,30,31,30,31};
        if(month == 2 && ((year%4 == 0 && year % 100 != 0) || year %400 == 0))
        {
            return 29;
        }

        return monthDays[month];
    }

    Date(int year = 0,int month = 1,int day = 1)
    {
        if(year >= 0 && month >= 1 && month <= 12 && day >= 1 && day <= GetMonthDay(year,month))
        {
            _year = year;
            _month = month;
            _day = day;
        }
        else
        {
            cout << "非法日期" << endl;
        }
    }

    // Date d2(d1);
    Date(const Date& d)
    {
        _year = d._year;
        _month = d._month;
        _day = d._day;
    }

    void Print()
    {
        cout << _year << "-" << _month << "-" << _day << endl;
    }

    // bool operator(Date* this,const Date& d)
    bool operator<(const Date& d)
    {
        if(_year < d._year) return true;
        else if(_year == d._year && _month < d._month) return true;
        else if(_year == d._year && _month == d._month && _day < d._day) return true;

        return false;
    }

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

    // d1 <= d1;
    // d1.operator(&d1,d2);
    bool operator<=(const Date& d)
    {
        return *this < d || *this ==d;//复用上面的来实现
    }

    bool operator>(const Date& d)
    {
        return !(*this <= d);// !表示逻辑取反
    }

    bool operator>=(const Date& d)
    {
        return !(*this < d);
    }

    bool operator!=(const Date& d)
    {
        return !(*this == d);
    }

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

int main()
{
    Date d1(2024,8,6);
    d1.Print();
    Date d2(2024,8,7);
    d2.Print();

    cout << (d1 < d2) << endl;

    system("pause");
    return 0;
}

上面包含了日期大小的基本比较判断，日期的合法判断。还有日期与天数的加减，读者可以自行实现一下。

2.赋值运算符的重载 

1.赋值运算符重载格式

  • 参数类型：const T&，传递引用可以提高传参效率。
  • 返回值类型：T&，返回引用可以提高返回的效率，有返回值目的是为了支持连续赋值
  • 检测是否自己给自己赋值
  • 返回*this：要复合连续赋值的含义
class Date
{
public:
    Date(int year = 1900,int month = 1,int day = 1)
    {
        _year = year;
        _month = month;
        _day = day;
    }
    
    Date(const Date& d)
    {
        _year = d._year;
        _month = d._month;
        _day = d._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;
};

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

#include <iostream>
using namespace std;

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

    Date(const Date& d)
    {
        _year = d._year;
        _month = d._month;
        _day = d._day;
    }

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

Date& operator=(Date& left,const Date& right)
{
    if(&left != &right)
    {
        left._year = right._year;
        left._month = right._month;
        left._day = right._day;
    }

    return left;
}

int main()
{
    cout << "Hello World!" << endl;

    system("pause");
    return 0;
}

运行结果：

编译失败，“operator=”必须是非静态成员。赋值运算符如果不显式实现，编译器会实现一个默认的。此时用户再在类外自己实现一个全局的赋值运算符重载，就和编译器在类中生成的默认赋值运算符重载冲突了，故赋值运算符重载只能是类的成员函数。

3.用户没有显式实现时，编译器会生成一个默认赋值运算符重载，以值的方式逐字节拷贝。注意：内置类型成员变量是直接赋值的，而自定义类型成员变量需要对应类的赋值运算符重载完成赋值。

#include <iostream>
using namespace std;

class Time
{
public:
    Time()
    {
        _hour = 1;
        _minute = 1;
        _second = 1;
    }

    Time& operator=(const Time& t)
    {
        cout << "operator=" << endl;
        if(this != &t)
        {
            _hour = t._hour;
            _minute = t._minute;
            _second = t._second;
        }

        return *this;
    }
private:
    int _hour;
    int _minute;
    int _second;
};

class Date
{
private:
    // 基本类型
    int _year;
    int _month;
    int _day;

    // 内置类型
    Time _t;
};

int main()
{
    Date d1;
    Date d2;
    d1 = d2;

    system("pause");
    return 0;
}

运行结果：

那么我们提出一个问题：既然编译器生成的默认赋值运算符重载函数已经可以完成字节序的值拷贝了，还需要自己实现吗？当然像日期类这样的类是没必要的。那么对于Stack类，我们来看一下。

class Stack
{
public:
    Stack(size_t capacity = 10)
    {
        _array = (int*)malloc(capacity*sizeof(int));
        if(_array == nullptr)
        {
            cout << "malloc申请空间失败" << endl;
            return;
        }
    }

    void Push(const int& data)
    {
        // CheckCapacity();
        _array[_size] = data;
        _size++;
    }

    ~Stack()
    {
        if(_array)
        {
            free(_array);
            _array = nullptr;
            _capacity = 0;
            _size = 0;
        }
    }
private:
    int *_array;
    size_t _size;
    size_t _capacity;
};

int main()
{
    Stack s1;
    s1.Push(1);
    s1.Push(2);
    s1.Push(3);
    s1.Push(4);
    Stack s2;
    s2 = s1;

    system("pause");
    return 0;
}

运行结果：

程序崩掉了。（s2 = s1，当s1给s2赋值时，编译器会将s1中内容原封不动地拷贝到s2中，这样会导致两个问题：1.s2原来的空间丢失了，存在内存泄漏。2.s1和s2共享一份内存空间，最后销毁时会导致同一份内存空间释放两次而引起程序崩溃。）

Note：如果类中未涉及到资源管理，赋值运算符是否实现都可以；一旦涉及到资源管理则必须要实现。

3.前置++和后置++重载

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

    void Print()
    {
        cout << _year << '-' << _month << '-' << _day << endl;
    }

    // 前置++：返回+1之后的结果
    Date& operator++()
    {// 注意：this指向的对象函数结束后不会销毁，故以引用方式返回提高效率
        _day += 1;
        return *this;
    }

    // 后置++
    Date operator++(int)
    {// 后置++是先使用后+1，因此需要返回+1之前的旧值，故需在实现时需要先将this保存一份，然后给this+1
        // 而temp是临时对象，因此只能以值的方式返回，不能返回引用
        Date temp(*this);
        _day += 1;
        return temp;
    }


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

int main()
{
    Date d1;
    Date d3;
    Date d2(2024,1,1);
    d1 = d2++;
    d3 = ++d2;
    cout << "d2++:" << endl;
    d1.Print(); d2.Print();
    cout << endl;
    cout << "++d2:" << endl;
    d3.Print(); d2.Print();
    cout << endl;

    system("pause");
    return 0;
}

运行结果：

前置++和后置++都是一元运算符，为了让前置++与后置++能正确重载，C++规定：后置++重载是多增加一个int类型的参数，但调用函数时该参数不用传递，编译器自动传递。

（6）const成员函数

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

class Date
{
public:
    // 显示日期信息：年-月-日
    void Display() const
    {
        cout << _year << '-' << _month << '-' << _day << endl;
    }
private:
    int _year;
    int _month;
    int _day;
};

编译器会把const成员函数处理成以下形式：

class Date
{
public:
    // 显示日期信息：年-月-日
    void Display(const Date* this)
    {
        cout << this->_year << '-' << this->_month << '-' << this->_day << endl;
    }
private:
    int _year;
    int _month;
    int _day;
};

（7）取地址及const取地址操作符重载

这两个默认成员函数一般不用重新定义，编译器会默认生成。

class Date
{
public:
    Date* operator&()
    {
        return this;
    }
    
    const Date* operator&() const
    {
        return this;
    }
private:
    int _year;
    int _month;
    int _day;
};

这两个运算符一般不需要重载，使用编译器生成的默认取地址的重载即可，只有特殊情况，才需要重载，比如想让别人获取到指定的内容。

敲代码的小马哥
关注
【23秋招c++后端面试技术突围】CAS 原子操作
m0_58687318的博客
10-17 372
就像你接了一杯水,这时水是满的,但是这个时候,你的同时很渴,过来拿你的水直接喝掉了一半,这时水剩下了一半,接着,你的同事又重新把你的水帮你接满了,那么这时你的水还是满的,相对于水来说,他还是满的,但是相对于杯子来说,他已经被用过了两次,一次是喝水,一次是接水,这就是ABA问题。你接了一杯水,然后旁边放上一张登记表,这个时候你同事过来,直接喝掉了一半,然后登记上,XXX喝掉了一半的水,然后去给你接满了,再次登记上,我给你接满了,这时,ABA的问题就得到了解决,你一看这个表就知道了一切。那么什么是ABA问题?
opencv 中的cvMat详解
热门推荐
彼岸花
03-25 1万+
1 cvMat简介 图像在计算机中是以数组的形式存放的，Mat是OpenCV中用于存放图像的数据结构。通过调用相关方法，我们能够实现对图像的输入输出以及一些操作。同时，Mat又不止可以作为图像容器，它也可以作为一种比较纯粹的描述矩阵这种数学对象的结构。它比C中的IplImage好的地方在于，由于它的“计数器”机制，我们不需要对它进行手动的内存回收，从而避免了常常困扰C/C++程序员的“内存泄
彼岸花开C++，类和对象（下）
2401_86606773的博客
08-14 944
类和对象的深层理解。
彼岸花开C++，类和对象（上）
2401_86606773的博客
08-06 1180
对于类的一个初步认识
彼岸花开C++，内存管理
2401_86606773的博客
08-15 1013
欢迎访问小马的博客，如果觉得小马的博客有帮助的话，记得点赞收藏加关注哦~~~
彼岸花开C++，string常用接口
2401_86606773的博客
08-23 814
欢迎访问小马的博客，如果觉得小马的博客有帮助的话，记得点赞收藏加关注哦~~~
彼岸花全套源码18_2.rar_Gh0st_Gh0st 彼岸_vc++_彼岸_彼岸花
07-15
在源码中，我们可以期待看到类、函数、对象和各种C++特性，如模板、异常处理、多态性和面向对象的设计原则。这些源码可能包含了网络通信模块，用于实现远程控制功能；可能会有命令执行、文件操作、屏幕监控等功能的...
Project1.zip
07-17
类和对象可用来封装学生、费用、缴费记录等实体。 2. **数据库连接**：使用ODBC或ADO等库连接到数据库，执行SQL语句进行数据的增删改查。 3. **图形用户界面**：可以使用Qt或wxWidgets等库创建跨平台的GUI，提供...
机器学习相关职位走向
彼岸花
09-05 4061
一、机器学习相关的公司分析 1、大的有师傅的公司 这类公司主要是百度，阿里和腾讯。共同的特点是数据很大，机器学习的团队比较庞大，一般进去的同学都可以有师傅带着学习，进步会比较快。 但是三个公司的特点也有所不同。 （1）百度 百度是我认为在业务和技术之间匹配的最好，并且从基础到应用搭配的最好的公司。机器学习方面的能力对于百度的广告，搜索，移动搜索，LBS,应用分发，
【C++初阶】：C++入门，引用概念及其性质
书山有路勤为径，学海无涯苦作舟。
09-10 1160
是的，你没看错，引用不仅可以做函数的参数，还可以做函数的返回值，我们之前写的具有返回值的函数返回的并不是直接将函数中的变量，而是返回的变量的一份临时拷贝，而拷贝是需要付出一定代价的，这样会降低我们代码的效率，但是如果我们用引用返回的话就可以避免拷贝的代价，在对程序性能要求高且允许使用引用的情况下，尽量使用引用返回。除了上述情况，引用的类型不同也会导致编译不同过，这是因为在发生类型转化的过程中，会产生临时变量，而临时变量具有常性，和常量一样，需要用。一个变量被引用后，可以继续被引用，也可以引用变量的引用。
【C++ 面试 - 新特性】每日 3 题（九）
Newin2020的博客
09-10 652
✍个人博客：Pandaconda-CSDN博客📣专栏地址：http://t.csdnimg.cn/fYaBd📚专栏简介：在这个专栏中，我将会分享 C++ 面试中常见的面试题给大家~
学懂C++（五十八）：深入详解 C++ COM编程开发技术
martian665的专栏
09-11 1226
学懂C++：深入详解 C++ COM编程开发技术
Linux 下 C/C++ 程序编译的过程
Teminator_的博客
09-08 9554
本文将介绍如何将 C/C++ 语言编写的程序转换成为处理器能够执行的二进制代码的过程，包括四个步骤：预处理（）编译（）汇编（）链接（在此之前，首先来看一下 GCC 工具链。
＜C++＞ set、map模拟实现
prodigy623的博客
09-10 863
set、map仿STL模拟实现
C和指针：预处理(#include/define/if...)
暮色年华的博客
09-10 725
预处理器把所有name替换成 stuff。在程序中扩展#define定义符号和宏时，需要涉及几个步骤：1.在调用宏时，首先对参数进行检查，看看是否包含了任何由#define 定义的符号。如果是，它们首先被替换。2.替换文本随后被插入到程序中原来文本的位置。对于宏，参数名被它们的值所替代。3.最后，再次对结果文本进行扫描，看看它是否包含了任何由#define 定义的符号。如果是，就重复上述处理过程。这样，宏参数和#define 定义可以包含其他#define定义的符号。但是，宏不可以出现递归。
【C++ && Qt day11】
wzj46的博客
09-11 250
2、头文件窗口文件。
CCF201903_1
m0_67663419的博客
09-14 115
【代码】CCF201903_1。
集群聊天服务器项目【C++】（二）Json的简单使用
最新发布
xaiobai123的博客
09-14 419
Json是一种轻量级的数据交换格式（也叫数据序列化方式）。Json采用完全独立于编程语言的文本格式来存储和表示数据。简洁和清晰的层次结构使得 Json 成为理想的数据交换语言。易于人阅读和编写，同时也易于机器解析和生成，并有效地提升网络传输效率。在网络传输中，一般有3中常见的序列化格式：XML，Json、ProtoBufProtoBuf：数据压缩编码传输，占用带宽小，复杂Json：相比与ProtoBuf更简单，但性能差一点XML：性能差本项目使用Json完成网络数据的序列化与反序列化。
Java泛型与集合类实验：Media子类Book, Newspaper, Video管理
实验目的是理解泛型技术，掌握泛型与普通类的区别，学习如何定义和使用泛型，同时熟悉Java集合框架中的类图关系，包括常用集合类和接口的运用。此外，还涉及到对系统管理模块的实践，如商品管理、订单管理和客户信息...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值