4.类与对象（下篇）explicit关键字、static关键字、友元函数、内部类、匿名对象。拷贝对象时编译器优化

最新推荐文章于 2024-07-11 18:23:19 发布
最新推荐文章于 2024-07-11 18:23:19 发布
阅读量612 收藏 9
点赞数 24
分类专栏： c++ 文章标签： 开发语言 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Q2691463021/article/details/137556442
版权

1. 再谈构造函数

1.1 构造函数体赋值

在创建对象时，编译器通过调用构造函数，给对象中各个成员变量一个合适的初始值。

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

​ 虽然上述构造函数调用之后，对象中已经有了一个初始值，但是不能将其称为对对象中成员变量的初始化，构造函数体中的语句只能将其称为赋初值，而不能称作初始化。因为初始化只能初始化一次，而构造函数体内可以多次赋值。

1.2 初始化列表

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

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

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

class Stack
{
public:
	/*
	// 方法一
	// 全部使用初始化列表来初始化
	Stack(int capacity = 4)
		:_a((int*)malloc(sizeof(int)*capacity))
		, _top(0)
		, _capacity(capacity)
	{
		if (_a == nullptr)
		{
			perror("malloc fail");
			exit(-1);
		}
	}
	*/

    // 方法二
	// 初始化列表和函数体内初始化可以混着来
	Stack(int capacity = 4)
		: _top(0)
		, _capacity(capacity)
	{
		cout << "Stack(int capacity = 4)" << endl;
		// 此处的初始化是函数体内的初始化
		_a = (int*)malloc(sizeof(int)*capacity);
		if (_a == nullptr)
		{
			perror("malloc fail");
			exit(-1);
		}
		memset(_a, 0, sizeof(int)*capacity);
	}
	
	~Stack()
	{
		cout << "~Stack()" << endl;

		free(_a);
		_a = nullptr;
		_top = _capacity = 0;
	}

	void Push(int x)
	{
		// ....
		// 扩容
		_a[_top++] = x;
	}

private:
	int* _a;  // 声明
	int _top;
	int _capacity;
};

初始化链表的注意事项

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

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

  • 引用成员变量

  • const成员变量

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

class A
{
public:
	A(int a)        //需要传参，所以不是默认构造函数
		:_a(a)
	{}
    
private:
	int _a;
};

class B
{
public:
	// 对象每个成员什么时候定义初始化呢？-- 初始化列表
	// 每个成员都要走初始化列表，就算不显示在初始化列表写，也会隐藏走
	// 如果在初始化列表显示写了就用显示写的初始化；
    
	// 否则：如果没有在初始化列表显示初始化
	// 1、内置类型，有缺省值用缺省值，没有就用随机值
	// 2、自定义类型，调用默认它的默认构造函数，如果没有默认构造就报错
	B()
		:_n(10)   		// const成员，必须在初始化列表初始化，否则就会报错
		, _m(2)   		// 如果没有显示写，则会使用缺省值进行初始化；缺省值也是走初始化链表时生效的
        , _ref(ref) 	// 引用也必须在初始化列表初始化，否则就会报错
		, _aa(11) 		// 自定义类型，如果没有显示写，自定义类型，调用默认它的默认构造函数，如果没有默认构造就报错
	{
		// _n = 10;  // 因为被const修饰，所以无法赋值，因此必须走初始化列表
	}

private:
	// const成员
    const int _n;  // 声明
	int _m = 1;    // 缺省值
    int& _ref;  // 引用

	A _aa;
};

int main()
{
    B b;
    
    return 0;
}

// 总结：
// 1.尽量使用初始化列表初始化
// 2.一个类尽量提供默认构造（推荐使用全缺省）

class MyQueue
{
public:
    // 不是默认构造函数，因此必须传参
	MyQueue(int capacity)   
		:_popST(capacity)   // 自定义类型，如果没有显示写，自定义类型，调用默认它的默认构造函数，如果没有默认构造就报错
		, _pushST(capacity) // 自定义类型，如果没有显示写，自定义类型，调用默认它的默认构造函数，如果没有默认构造就报错
	{}

	void push(int x)
	{
		_pushST.Push(x);
	}
    
private:
	Stack _pushST;
	Stack _popST;
	size_t _size = 0;  // 如果没有显示写在初始化列表，则会使用缺省值进行初始化；缺省值也是走初始化链表时生效的
};

int main()
{
	MyQueue q(10);

	return 0;
}

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

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

class A 
{
public:
    A(int a)
       :_a1(a)
       ,_a2(_a1)  // 按声明顺序初始化，此时a1还没有被初始化，因此a1是随机值
   {}
    
    void Print() 
    {
        cout<<_a1<<" "<<_a2<<endl;
    }
    
private:
    int _a2;   // 按声明顺序初始化，因此是先初始化_a2,再初始化_a1，而不是按初始化列表的顺序
    int _a1;
};

int main() 
{
    A aa(1);
    aa.Print();
}

A. 输出1  1 
B.程序崩溃
C.编译不通过
D.输出1  随机值    // 正确答案为D

1.3 explicit关键字

// explicit adj.明确的，详细的

在 C++11 中，explicit 关键字用于声明单参数构造函数（或者转换函数）时，指示编译器不要将该构造函数用于隐式类型转换。这样做可以防止意外的隐式类型转换，提高代码的可读性和安全性。

具体来说，explicit 关键字可以用在构造函数的声明前面，也可以用在转换函数的声明前面。它告诉编译器在执行隐式转换时不要使用这些函数。

// C++98(只可以支持单参数类型转化)
class Date
{
public:
    // 构造方法一
	// 1. 单参构造函数，
    // 没有使用explicit修饰，可以进行隐式类型转换
	// explicit修饰构造函数，禁止类型转换
	Date(int year)
		:_year(year)
	{}

	
    // 构造方法二
	// 2. 虽然有多个参数，但是创建对象时，后两个参数可以不传递（使用缺省值就可以），
    // 没有使用explicit修饰，具有类型转换作用
	// explicit修饰构造函数，禁止类型转换
	explicit Date(int year = 1, int month = 1, int day = 1)  // 全缺省，传1个参数也是可行的
	: _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;
};

void Test1()
{
    // 不论使用构造方法一还是构造方法二都是可行的，不存在隐式类型转换
    // 所以有没有explicit都是无关紧要的
    Date d10(2022);
    // 方法一和方法二不能同时存在，会造成二义性
}

void Test2()
{
    Date d20(2022);
    
    // 用一个整形变量给日期类型对象赋值
    // 实际编译器背后会用2023构造一个无名对象，最后用无名对象给d1对象进行赋值
    d20 = 2023;
    // 将2023赋值给一个日期类对象，其实就是将整型转化为了一个日期类对象（这个日期类对象是临时的），这个转化就是隐式转化
    // 再用隐式转化的这个日期类对象赋值给d20这个日期类对象
    
    // 方法一：没有被explicit修饰构造函数，因此允许发生隐式转化，所以可以通过编译
    // 方法二：因为explicit修饰构造函数，禁止了单参构造函数类型转换的作用
}

int main()
{
	int i = 0;
    // i是int类型，赋值给double类型，会产生一个临时变量，i被截取之后给到临时变量，临时变量会赋值给d
    // 产生的这个临时变量就是，隐式转化类型后产生的变量
	double d = i;          
    
	const double& rd = i;
    // 也会产生一个临时变量，因为临时变量具有常性，因此引用临时变量，一定要加const

    // 隐式类型的转换
	Date d1(2022);
	
	Date d2 = 2022;   
    // 2022不是Date类型，因此也会产生一个临时变量
	const Date& d5 = 2022;
    // 同上

	Date d3(d1);   // 拷贝构造的两种形式
	Date d4 = d1;

	return 0;
}

image-20221211182002010

// 多参数构造 -- C++11
class Date
{
public:
	// 多参数构造
	// explicit Date(int year, int month, int day)    // 加上explicit则无法进行类型转化
	Date(int year, int month, int day)
		: _year(year)
		, _month(month)
		, _day(day)
	{}

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

int main()
{
    // d1等价于d2
	Date d1 = { 2022, 10, 12 };  // 如果构造函数被explicit修饰，则编译无法通过
	Date d2(2022, 10, 12 );

	const Date& d3 = { 2022, 10, 12 }; // 如果构造函数被explicit修饰，则编译无法通过

	return 0;
}

2. static成员

2.1 概念

用static修饰的成员变量，称之为静态成员变量；

用static修饰的成员函数，称之为静态成员函数。

静态成员变量一定要在类外进行初始化

// 面试题：实现一个类，计算程序中创建出了多少个类对象。
// case1:
class A
{
public:
	A(int a = 0)     // 构造函数
		:_a(a)
	{
		++N;
        cout << " constructor " << endl;
	}

	A(const A& aa)   // 拷贝构造函数
		:_a(aa._a)
	{
		++N;
        cout << " copy " << endl;
	}

private:
	int _a;

public:
	static int N; // 静态成员变量必须在类外定义，定义时不添加static关键字，类中只是声明
};


// 生命周期是全局的，作用域受类域限制
int A::N = 0;  // 定义初始化(静态成员变量初始化，必须在类外初始化，因为静态成员变量在静态区存储)


void F1(A aa)
{}


A F2()
{
	A aa;            // 调用构造函数创建对象aa
	return aa;       // 传参返回会调用一次拷贝构造函数
}


int main()
{
	A aa1(1);   // 调用一次构造函数
	A aa2 = 2;  // 调用一次构造函数

	A aa3 = aa1;  // 调用一次拷贝函数

	cout << A::N << endl;   // 打印结果为3

	F1(aa1);
	cout << A::N << endl;   // 打印结果为4；  传参会进行一次拷贝构造
    
    
    // 类静态成员即可用  类名::静态成员 或者 对象.静态成员  来访问
	F2();
	cout << A::N << endl;   // 打印结果为6
	cout << aa1.N << endl;
    // 类里面的static--> static成员变量，属于类，并且每个类的对象共享
	
    
	A* ptr = nullptr;
	cout << ptr->N << endl;  // static修饰的N被共享，因此也可以这样被调用


	return 0;
}
// 打印结果为：
/*
constructor
constructor
copy
3
copy
4
constructor
copy
6
6
6
*/

// case2:
class A
{
public:
	A(int a = 0)
		:_a(a)
	{
		++N;
        cout << " constructor " << endl;
	}

	A(const A& aa)
		:_a(aa._a)
	{
		++N;
        cout << " copy " << endl;
	}

	// 静态成员函数没有隐藏的this指针，不能访问任何非静态成员
	static int GetN()
	{
		return N;
	}

private:
	int _a;

	static int N; // 声明
};

// 生命周期是全局的，作用域受类域限制
int A::N = 0;  // 定义初始化

void F1(A aa)
{}

A F2()
{
	A aa;   // 调用一次构造函数
	return aa;  // 调用一次拷贝构造函数
}

 
int main()
{
	F2();  
	A aa4;    // 调用一次构造函数
    // 没有用static修饰GetN_1()，则必须先创建一个对象，再通过这个对象调用GetN_1()
	cout << aa4.GetN_1() << endl;   // 打印结果为3

    // 使用static修饰GetN()，则可以直接调用GetN()
	cout << A::GetN() << endl;    // 打印结果为3
	cout << aa4.GetN_1() << endl;// 也可以通过类对象来调用静态成员函数
	return 0;
}
/*
// 打印结果为：
constructor
copy
constructor
3
3
3
*/

2.2 特性

  1. 静态成员为所有类对象所共享，不属于某个具体的对象，存放在静态区

  2. 静态成员变量必须在类外定义，定义时不添加static关键字，类中只是声明

  3. 类静态成员即可用 类名::静态成员 或者 对象.静态成员 来访问

  4. 静态成员函数没有隐藏的this指针，不能访问任何非静态成员

  5. 静态成员也是类的成员，受public、protected、private 访问限定符的限制

【问题】

  1. 静态成员函数可以调用非静态成员函数吗？

答：静态成员函数是不可以调用非静态成员函数(因为静态成员函数是没有this指针的)

  1. 非静态成员函数可以调用类的静态成员函数吗？

答：可以（因为静态成员为所有类对象所共享，不属于某个具体的对象，存放在静态区）

要求类对象只能在栈上面

class A
{
public:
    // 通过函数GetObj来创建一个类类型为A的静态对象
    // 必须放在静态区；否则无法区分是先创造了对象，再调用了函数，还是先调用了函数再创建对象
	static A GetObj(int a = 0)   
	{
        // 函数 GetObj 内部的对象 aa 是在函数执行时自动创建的，称为自动变量或者局部变量。它们被分配在函数的栈帧中，栈帧是用于存储函数局部变量和临时数据的内存区域。当函数执行结束时，栈帧中的局部变量被自动销毁，因此 aa 对象也随之被销毁。
		A aa(a);          // 此时创建的对象，一定在栈上面
		return aa;
	}

private:
	A(int a = 0)
		:_a(a)
	{}

private:
	int _a;
};

int main()
{
    /*
    // 此时，由于构造函数为私有，因此在类外面就无法调用构造函数
    // 在 C++ 中，static 关键字用于声明静态成员变量或静态局部变量。当类的静态成员变量被声明为静态时，它们只会被创建一次，并且在程序的整个生命周期内存在。这意味着它们的生命周期长于栈上的局部变量，而且它们不是在函数调用时创建的，而是在程序启动时就已经创建好了。
静态成员变量在程序启动时被初始化，而且它们的值在整个程序运行期间都保持不变。因此，静态成员变量存储在静态存储区，而不是栈上。
	static A aa1;    
	// 想要在堆上new一个A类型的对象是不可能成功的（默认构造函数已经被禁止了,new无法调用默认构造函数）
	A* ptr = new A;  
	A aa2;
	*/


	A::GetObj(10);

	return 0;
}

3. 友元

  • 友元提供了一种突破封装的方式，有时提供了便利。但是友元会增加耦合度，破坏了封装，所以友元不宜多用。
  • 友元分为：友元函数和友元类

3.1 友元函数

问题：现在尝试去重载operator<<，然后发现没办法将operator<<重载成成员函数。因为cout的输出流对象和隐含的this指针在抢占第一个参数的位置。this指针默认是第一个参数也就是左操作数了。但是实际使用中cout需要是第一个形参对象，才能正常使用。所以要将operator<<重载成全局函数。但又会导致类外没办法访问成员，此时就需要友元来解决。operator>>同理。

详情可以参考我的另一篇文章类与对象(中篇)

class Date
{
public:
	Date(int year, int month, int day)
		: _year(year)
		, _month(month)
		, _day(day)
	{}
	
	// d1 << cout; -> d1.operator<<(&d1, cout); 不符合常规调用
    // 因为成员函数第一个参数一定是隐藏的this，所以d1必须放在<<的左侧；
	// 但是这有不符合常规调用，因此我们考虑将其定义为全局变量, 
	// 定义为全局变量又无法访问类的私有成员，因此就需要友元函数
    
    // 错误演示
	ostream& operator<<(ostream& _cout)
	{
		_cout << _year << "-" << _month << "-" << _day << endl;
		return _cout;
	}
private:
	int _year;
	int _month;
	int _day;
};
  • 友元函数可以直接访问类的私有成员，它是定义在类外部的普通函数，不属于任何类，但需要在类的内部声明，声明时需要加friend关键字。
class Date
{
	// 可以将声明定义在类的任意位置
	friend ostream& operator<<(ostream& _cout, const Date& d); 
	friend istream& operator>>(istream& _cin, Date& d);

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

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

// 因为有友元声明，所以可以访问类的私有成员函数
ostream& operator<<(ostream& _cout, const Date& d)
{
	_cout << d._year << "-" << d._month << "-" << d._day;
	return _cout;
}

istream& operator>>(istream& _cin, Date& d) 
{
	_cin >> d._year;
	_cin >> d._month;
	_cin >> d._day;
	return _cin;
}

int main()
{
	Date d;
	cin >> d;
	cout << d << endl;
	return 0;
}
  • 友元函数可访问类的私有和保护成员，但不是类的成员函数
  • 友元函数不能用const修饰
  • 友元函数可以在类定义的任何地方声明，不受类访问限定符限制
  • 一个函数可以是多个类的友元函数
  • 友元函数的调用与普通函数的调用原理相同

3.2 友元类

  • 友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类中的非公有成员。

1.友元关系是单向的，不具有交换性。

  • 比如下述Time类和Date类，在Time类中声明Date类为其友元类，那么可以在Date类中直接访问Time类的私有成员变量，但想在Time类中访问Date类中私有的成员变量则不行。

2.友元关系不能传递

  • 如果C是B的友元， B是A的友元，则不能说明C时A的友元。

3.友元关系不能继承，在继承位置再给大家详细介绍。

class Time
{
	// 声明日期类为时间类的友元类，则在日期类中就直接访问Time类中的私有成员变量
	friend class Date;   
	
public:
	Time(int hour = 0, int minute = 0, int second = 0)
		: _hour(hour)
		, _minute(minute)
		, _second(second)
	{}

private:
	int _hour;
	int _minute;
	int _second;
};

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

	void SetTimeOfDate(int hour, int minute, int second)
	{
		// 直接访问时间类私有的成员变量
		_t._hour = hour;
		_t._minute = minute;
		_t._second = second;
	}

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

4. 内部类

概念：如果一个类定义在另一个类的内部，这个内部类就叫做内部类。

  • 内部类是一个独立的类，它不属于外部类，更不能通过外部类的对象去访问内部类的成员。外部类对内部类没有任何优越的访问权限。

  • 注意：内部类就是外部类的友元类，参见友元类的定义，内部类可以通过外部类的对象参数来访问外部类中的所有成员。但是外部类不是内部类的友元。

特性：

  1. 内部类可以定义在外部类的public、protected、private都是可以的。
  2. 注意内部类可以直接访问外部类中的static成员，不需要外部类的对象/类名。
  3. sizeof(外部类)=外部类，和内部类没有任何关系。
// 相当于两个独立的类
// B类的访问受A的类域和访问限定符的限制
class A
{
private:
	int _a;
	static int k;

public: 
    
    // B天生就是A的友元
	class B
	{
		int _b;

        // 可以直接访问A的成员
		void foo(const A& a)
		{
			cout << k << endl;//OK
			cout << a._a << endl;//OK
		}
	};
    
};

int A::k = 1;

int main()
{
	cout << sizeof(A) << endl;  // sizeof(外部类)=外部类
	A aa;

	A::B bb;  // B类的访问受A的类域和访问限定符的限制

	return 0;
}

**5.**匿名对象

class A
{
public:
	A(int a = 0)
		:_a(a)
	{
		cout << "A(int a)" << endl;
	}

	~A()
	{
		cout << "~A()" << endl;
	}
    
private:
	int _a;
};

class Solution {
public:
	int Sum_Solution(int n) {
		//...
		return n;
	}
};

A F()
{
	//A ret(10);
	//return ret;
    
    // 这种用匿名对象更加简洁；且后续不会用到这个对象（这个对象随着函数的生命周期会被自动销毁）
	return A(10);   
}

int main()
{
	// 有名对象
	A aa0;
	A aa1(1);
	A aa2 = 2;

	//A aa3();  // 错误演示；匿名对象不是这么规定的

	// 匿名对象 --声明周期就在当前这一行（出了这一行，匿名对象的生命周期旧结束了）
	A();   // 出了这一行，系统就会调用析构函数
	A(3);

    // 创建对象只是为了调用它的一个成员函数，
    // 如果不适用匿名对象，那么还要先创建一个Solution对象，再通过这个对象来调用其成员函数Sum_Solution
	//Solution so;        
	//so.Sum_Solution(10);

    // 如果使用匿名对象更加简洁；并且编译器会在这一行之后自动调用析构函数，释放其占用的空间
	Solution().Sum_Solution(10);  

	return 0;
}

**6.**拷贝对象时的一些编译器优化

class A
{
public:
    // 构造函数
	A(int a = 0)
		:_a(a)
	{
		cout << "A(int a)" << endl;
	}

    // 拷贝函数
	A(const A& aa)
		:_a(aa._a)
	{
		cout << "A(const A& aa)" << endl;
	}

    // 运算符重载
	A& operator=(const A& aa)
	{
		cout << "A& operator=(const A& aa)" << endl;

		if (this != &aa)
		{
			_a = aa._a;
		}

		return *this;
	}

    // 析构函数
	~A()
	{
		cout << "~A()" << endl;
	}

private:
	int _a;
};

void f1(A aa)
{}

A f2()
{
	A aa;           // 构造
	return aa;      // 传值返回，进行拷贝构造
}

A f3()
{
	/*
	A aa(10);
	return aa;
	*/
    
	return A(10);
}

// 《深度探索C++对象模型》

int main()
{
	// 优化场景1
    // 1是一个整型，aa1是一个类对象
    // 类型不同，会先生成一个临时变量，再将临时变量赋值
    // 但是编译器会将其进行优化，直接使用1来构造aa1类对象
    // A tmp(1) + A aa1(tmp) -> 优化 A aa1(1)
	A aa1 = 1;  

	// 优化场景2
	/*
	// void f1(A aa)
	// 构造+拷贝构造（两行）
	A aa1(1);    // 构造 
	f1(aa1);     // 拷贝构造
	*/     

    /*
    // 构造了一个匿名对象A(1)，再将其拷贝传参给f1，
    // 编译器会进行优化，优化后，直接使用1构造一个A类对象给函数f1
	f1(A(1));   // 构造 + 拷贝构造  -> 优化 构造 （1行）
	f1(1);  	// 构造 + 拷贝构造  -> 优化 构造 （1行）
	*/

	// f2();	     // 构造+拷贝构造   
	// A ret = f2(); // 构造+拷贝构造+拷贝构造 ->优化 构造+拷贝构造

	/*
	A ret;
	ret = f2();
	*/   // 构造+拷贝构造+拷贝构造； 由于ret对象已经存在所以无法优化

    // 直接使用10来构造这个ret对象
	A ret = f3();  //  构造+拷贝构造+拷贝构造 -> 优化 -> 构造


	return 0;
}

image-20221212013923640

7. 再次理解类和对象

现实生活中的实体计算机并不认识，计算机只认识二进制格式的数据。如果想要让计算机认识现实生活中的实体，用户必须通过某种面向对象的语言，对实体进行描述，然后通过编写程序，创建对象后计算机才可以认识。比如想要让计算机认识洗衣机，就需要：

  1. 用户先要对现实中洗衣机实体进行抽象—即在人为思想层面对洗衣机进行认识，洗衣机有什么属性，有那些功能，即对洗衣机进行抽象认知的一个过程

  2. 经过1之后，在人的头脑中已经对洗衣机有了一个清醒的认识，只不过此时计算机还不清楚，想要让计算机识别人想象中的洗衣机，就需要人通过某种面相对象的语言(比如：C++、Java、Python等)将洗衣机用类来进行描述，并输入到计算机中

  3. 经过2之后，在计算机中就有了一个洗衣机类，但是洗衣机类只是站在计算机的角度对洗衣机对象进行描述的，通过洗衣机类，可以实例化出一个个具体的洗衣机对象，此时计算机才能洗衣机是什么东西。

  4. 用户就可以借助计算机中洗衣机对象，来模拟现实中的洗衣机实体了。

5.在类和对象阶段，大家一定要体会到，类是对某一类实体(对象)来进行描述的，描述该对象具有那些属性，那些方法，描述完成后就形成了一种新的自定义类型，才用该自定义类型就可以实例化具体的对象。

image-20221212151153624

8. 练习题

1.求1+2+3+…+n，要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句（A?B:C）OJ链接

image-20240409154432253

class Solution {
public:
    int Sum_Solution(int n) {
        // 使用等差数列的求和公式（首项+尾项）*项数/2 就是等差数列的和
        return ((1+n) * n) >> 1;
        
    }
};

// 提供的解题思路
// case1:
class sum
{
public:
    // 构造函数(无参构造函数)
    sum()    
    {
        _ret += _i;
        ++_i;
    }

    static int GetRet()   // 静态成员函数
    {
        return _ret;
    }

private:
    static int _i;      // 需要在类外面进行定义和初始化;
    static int _ret;    // 需要在类外面进行定义和初始化;

};

int sum::_i = 1;
int sum::_ret = 0;

class Solution {
public:
    int Sum_Solution(int n) 
    {
        // 创建一个sum类的数组，这个数组的大小为n，那么就会调用n次构造函数
        sum arr[n];  

        return sum::GetRet();
    }
};

// case2:（使用内部类的方法）
class Solution
{
public:
    int Sum_Solution(int n) 
    {
        sum arr[n];  // 调用N次构造函数

        return _ret;
    }

    // sum是Solution的内部类
    class sum
    {
    public:
        sum()    // 构造函数
        {
           _ret += _i;
            ++_i;
        }
    };


private:
    static int _i;      // 需要在类外面进行定义;
    static int _ret;

};

int Solution::_i = 1;
int Solution::_ret = 0;

2.计算日期到天数的转换 OJ链接

image-20240409160158908

// 解题思路
#include <iostream>
using namespace std;

int main()
{
    // 输入
    int year,month,day;
    cin >>year>>month>>day;

    // 提前计算好从1月初到对应月份的天数（平年） 
    int monthDays[13] = {0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365};

    // 计算1月初到上月底的天数再加上当月的天数
    int n = monthDays[month-1]+day;

    // 如果当年是闰年，且是2月之后，再给总天数加1
    if(month > 2 && ((year % 400 == 0) || (year % 4 == 0 && year % 100 != 0)))
    {
        n += 1;
    }


    cout << n <<endl;

    return 0; 
}
the_nov
关注
  • 24
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c/c++拷贝构造函数和关键字explicit详解
08-27
C++中的拷贝构造函数和关键字explicit详解 C++中的拷贝构造函数是一种特殊的构造函数，它用于初始化对象时拷贝另一个对象的内容。拷贝构造函数的格式为`Type::Type(const Type&)`，其中`Type`是类的名称。拷贝构造...
C++类和对象的基本概念笔记
05-11
- 构造函数的调用：在创建对象时自动调用，析构函数在对象销毁时自动调用，两者调用顺序与声明相反。 7. **构造函数的调用规则**： 用户定义的构造函数会影响默认构造函数和拷贝构造函数的存在。用户定义的有参...
explicit关键字 和 static成员
pengpeng_code的博客
08-15 181
/声明为 static的类成员 称为 类的静态成员， 用static修饰的成员变量，称之为 静态成员变量；用staticx修饰的成员函数，称之为 静态成员函数。//静态成员变量一定要在类外进行定义（初始化）。//对比：普通成员变量在初始化列表进行定义，而静态成员变量必须要在类外进行定义；//性质：//1、静态成员为所有 类对象所共享，不属于某个具体的对象，存放在静态区。//2、静态成员变量 必须在 类外定义， 定义时不添加static关键字，类中只是声明。
c++ - 类与对象 - explicit关键字 | static成员 | 友元 | 内部类 | 匿名对象
2302_79539362的博客
04-19 1023
类与对象的一些语法 ：explicit关键字 | static成员 | 友元 | 内部类 | 匿名对象
【C++】explicit关键字详解（explicit关键字是什么? 为什么需要explicit关键字? 如何使用explicit 关键字）
weixin_45031801的博客
04-16 8470
在我们自己平时写 C++ 代码的时候，较少会用到 explicit关键字 。但是在C++相关的标准类库中，看到explicit关键字的频率还是很高的。既然出现的频率这么高，那么我们就来看看explicit关键字的作用到底是干什么的。
C++类与对象(6)—初始化列表、explicit关键字、static成员
Han同学
11-25 1388
C++类与对象(6)—初始化列表、explicit关键字、static成员
C++类和对象下(初始化列表,静态成员,explicit关键字,友元)
Wzs040810的博客
11-03 564
C++类和对象下(初始化列表,静态成员,explicit关键字,友元)
C++ Explicit关键字详细解析
09-05
在C++编程语言中，`explicit`关键字是一个非常重要的特性，它主要用于控制类的构造函数如何参与类型转换。本文将详细解析`explicit`关键字的用途、意义以及它如何影响类对象的创建和赋值。 `explicit`关键字用于...
C++中的explicit关键字实例浅析
08-31
`explicit`关键字在C++中是一个非常重要的特性，它用于控制类的构造函数是否允许进行隐式类型转换。在默认情况下，如果一个类有一个接受单个参数的构造函数，那么这个构造函数可以被用来进行隐式类型转换。然而，...
新型开发语言的试用感受-仓颉语言发布之际
opendba的专栏
07-03 2025
Zig、Odin、Mojo、codon、carbon、nim等语言的使用感受
C++ 多态
wxk2227814847的博客
07-10 565
多态是C++语言的三大特性之一，另两个特性是封装和继承。多态性使得对象可以根据运行时的实际类型来表现出不同的行为，从而实现灵活和可扩展的设计。在软件开发过程中，多态能够提高代码的复用性和可维护性，减少重复代码，并提供更加抽象和通用的接口。本文将详细探讨C++中的多态，包括其定义、构成、虚函数、抽象类以及实现原理，帮助读者全面理解这一重要概念。
python-torch加载c++与内核函数
weixin_40777649的博客
07-11 235
python 在线加载.cu 文件python 加载.cu 文件方式2二、实现python 在线加载.cu 文件python 加载c++ 方法采用的是torch.utils.cpp_extension包的扩展方法。直接加载cu文件，则采用torch.utils.cpp_extension.load() 方法。"fused",sources=[],具体： fused_bias_act.cpp//scalar_t y;
鸿蒙开发：Universal Keystore Kit（密钥管理服务）【明文导入密钥(C/C++)】
m0_70748845的博客
07-07 425
以明文导入ECC密钥为例。具体的场景介绍及支持的算法规格。
C语言-动态内存管理
m0_73605503的博客
07-07 1097
在C语言编程中，动态内存管理是一个至关重要的概念。它不仅涉及到程序如何高效地使用内存资源，还影响到程序的稳定性和性能。通过动态分配内存，程序可以根据运行时的需求灵活地调整内存使用，这对于处理不确定的数据量和实现高效的资源利用尤为重要。在这篇文章中，我们将深入探讨C语言中的动态内存管理机制，了解如何使用标准库函数如 malloc、calloc、realloc 和 free，并讨论一些常见的内存管理陷阱和最佳实践。
C++ 入门08：运算符重载
最新发布
LF__plus的博客
07-11 532
在前面的文章学习中，我们学习了类和对象的基础知识以及构造函数、拷贝构造函数、静态成员和常量成员。今天，我们将深入学习运算符重载。运算符重载是 C++ 的一大特色，它使得我们可以对类对象使用类似于基本数据类型的运算符，从而使代码更加简洁和易读。
C++初探究（2）
Frenemy__的博客
07-09 1281
public:// 成员函数private:// 成员变量int* array;size_t top;而我们如果想要对函数定义，则需要专门使用类域来定义函数.
解释 C 语言中的函数重载机制（注意：C 语言不支持函数重载）？
技术笔记
07-11 251
虽然 C 语言不支持函数重载这一直接的特性，但通过合理地设计函数名、利用预处理器或使用函数指针和结构体等方法，我们仍然可以在一定程度上实现类似的功能，以满足不同参数类型的操作需求。然而，这些方法相较于真正的函数重载，在代码的简洁性和可读性上可能存在一定的不足。在实际编程中，选择哪种方法取决于具体的应用场景和编程需求。如果对函数重载有强烈的需求，可能考虑使用支持该特性的编程语言，如 C++。但对于一些简单的 C 语言项目，通过上述的模拟方法也能够有效地处理不同类型参数的函数调用问题。🎉相关推荐。
初识C++
2301_80662872的博客
07-11 347
现在有一个项目分配给两个人让他们实现。他们写的都没问题但是它们一合并就出现了命名冲突的问题。在C++里就可以避免此问题的发生。C++提出了命名空间这是对标识符的名称进行本地化，以避免命名冲突。定义命名空间需要用到namespace关键字，后面接命名空间的名字，然后接一对{}即可。int a = 1;int b = 2;命名空间里面不止可以定义变量也可以定义函数和类型，注意一个命名空间就定义了一个新的作用域，命名空间里的所有内容只限于该命名空间中。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值