初始化列表+匿名对象+static成员

最新推荐文章于 2024-07-22 09:38:37 发布
最新推荐文章于 2024-07-22 09:38:37 发布
阅读量72 收藏
点赞数 1
分类专栏： C++ 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_61522065/article/details/129826672
版权

构造函数体赋值

创建一个类对象时，编译器通过调用构造函数，给类对象中各个成员变量赋初值：

class Date
{
public:
	//构造函数
	Date(int year = 2022, int month = 4, int day = 19)
	{
		_year = year;
		_month = month;
		_day = day;
	}
 
private:
	int _year;
	int _month;
	int _day;
};
虽然上述构造函数调用之后，对象中已经有了一个初始值，但是不能将其称为对对象中成员变量
的初始化， 构造函数体中的语句只能将其称为赋初值，而不能称作初始化。因为 初始化只能初始
化一次，而构造函数体内可以多次赋值。 
class Date
{
public:
	//构造函数
	Date(int year = 2022, int month = 4, int day = 19)
	{
		_year = year;
		_month = month;
		_day = day;
        _year = 2023;//构造函数体内允许对成员变量进行多次赋值
	}
 
private:
	int _year;
	int _month;
	int _day;
};

用初始化列表初始化对象

1.初始化列表用法

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

class Date
{
public:
	//构造函数
	Date(int year = 2022, int month = 4, int day = 19)
		:_year(year) //初始化列表初始化
		,_month(month)
		,_day(day)
	{}
 
private:
	int _year;
	int _month;
	int _day;
};

2.初始化列表特性

（1）初始化列表能只能初始化一次，多次初始化会报错：

class Date
{
public:
	//构造函数
	Date(int year = 2022, int month = 4, int day = 19)
		:_year(year) 
		,_month(month)
		,_day(day)
        ,_month(month) //err: 初始化列表多次初始化
	{}
 
private: 
	int _year;
	int _month;
	int _day;
};

编译器也允许构造函数赋初值和初始化列表初始化混用：

class Date
{
public:
	//构造函数
	Date(int year = 2022, int month = 4, int day = 19)
		:_year(year)  //两者混用
		,_month(month)
	{
		_day = day;
	}
 
private:
	int _year;
	int _month;
	int _day;
};

混用时初始化列表初始化和构造函数赋初值不冲突：

但是是初始化优先，因为赋初值相当于是给的缺省值，别人初始化了就初始化，没有就缺省值。

class Date
{
public:
	//构造函数
	Date(int year = 2022, int month = 4, int day = 19)
		: _year(year) //两者不冲突
		, _month(month)
	{
		_day = day;
        _year = 2023;
	}
 
private:
	int _year;
	int _month;
	int _day;
};

但混用时初始化列表初始化还是要遵循只能初始化一次成员变量的原则：

class Date
{
public:
	//构造函数
	Date(int year = 2022, int month = 4, int day = 19)
		: _year(year) //初始化列表初始化
		, _month(month)
		, _year(2023)  //_year在初始化列表里被初始化了两次，不允许
	{
		_day = day;
	}
 
private:
	int _year;
	int _month;
	int _day;
};

（2）const成员变量、引用成员变量、没有默认构造函数的自定义类型成员只能在初始化列表初始化。

①const成员变量必须在定义的时候初始化

class Date
{
public:
	//构造函数
	Date(int year = 2022, int month = 4, int day = 19)
		: _year(year) 
		, _month(month)
		, _n(2) //const成员变量必须使用初始化列表进行初始化
	{
		_day = day;
		//_n = 2; //const成员变量不能在函数体内初始化
	}
 
private:
	int _year;
	int _month;
	int _day;
 
	const int _n = 1;
};

②引用成员变量必须在定义的时候初始化

class Date
{
public:
	//构造函数
	Date(int year = 2022, int month = 4, int day = 19)
		: _year(year) 
		, _month(month)
		,_ref(year)//引用成员变量要在初始化列表初始化
	{
		_day = day;
		//_ref = year; //引用成员变量不能在函数体内初始化
	}
 
private:
	int _year;
	int _month;
	int _day;
 
	int& _ref;
};

③没有默认构造函数的自定义类型成员变量

#include <iostream>
using namespace std;
 
class A
{
public:
	
	//默认构造函数是不用传参就可以调用的构造函数，有3种：
	//1.无参默认构造函数
	//2.带参全缺省的默认构造函数
	//3.我们不写，编译器自动生成的默认构造函数
 
	A(int x)//不属于以上任何一种，所以A类的对象没有默认构造函数
	{
		cout << "A(int x)" << endl;
		_x = x;
	}
 
private:
	int _x;
};
 
class Date
{
public:
	//构造函数
	Date(int year = 2022, int month = 4, int day = 19)
		: _year(year) 
		, _month(month)
		, _a(20)//没有默认构造函数的自定义类型成员变量必须在初始化列表进行初始化
	{
		_day = day;
	}
 
private:
	int _year;
	int _month;
	int _day;
 
	A _a;
};

const成员变量、引用成员变量、没有默认构造函数的自定义类型成员变量必须在初始化列表内初始化的原因：

①初始化列表是对象的成员变量定义的地方。

②对象的内置类型成员变量在初始化列表定义时没有要求必须初始化，因此既可以在初始化列表进行初始化，也可以在构造函数体内初始化。

③而const成员变量、引用成员变量、没有默认构造函数的自定义类型成员变量不能先定义再初始化，它们在初始化列表内定义，并且必须在定义时就初始化，因此必须在初始化列表内初始化。

（3） 尽量使用初始化列表初始化，因为不管是否使用初始化列表，虽然对于内置类型没有差别，但是对于自定义类型成员变量，一定会先使用初始化列表初始化。

为什么会先使用初始化列表初始化？

如下，Date类没有默认构造函数，因为22行的构造函数不属于默认构造函数中的任意一种，在对Date类的对象d进行初始化时，会调用Date类的默认构造函数，所以对象d的day实参12和hour实参12都没有被传进去，_t作为Date类的自定义类型成员变量会调用Time类的默认构造函数，_hour默认传参为0，因此打印_hour的值也为0，d的参数没有传成功：

#include<iostream>
using namespace std;
 
class Date; // 前置声明
class Time
{
	friend class Date; // 声明日期类为时间类的友元类，则在日期类中就直接访问Time类中的私有成员变量
public:
	Time(int hour = 0)
		: _hour(hour)
	{
		cout << _hour << endl;
	}
 
private:
	int _hour;
};
 
class Date
{
public:
	Date(int day, int hour)
	{}
 
private:
	int _day;
	Time _t;
};
 
int main()
{
	Date d(12, 12);
	return 0;
}

假如Date类的构造函数不使用初始化列表进行初始化，使用函数体内初始化时，要把Date类的构造函数的形参hour的值给d，那么就必须构造一个Time类对象t，对该对象传参传hour，再使用赋值运算符重载函数将对象t拷贝给_t：

#include<iostream>
using namespace std;
 
class Date; // 前置声明
class Time
{
	friend class Date; // 声明日期类为时间类的友元类，则在日期类中就直接访问Time类中的私有成员变量
public:
	Time(int hour = 0)
		: _hour(hour)
	{
		cout << _hour << endl;
	}
 
private:
	int _hour;
};
 
class Date
{
public:
    //自定义类型，不使用初始化列表，就需要使用构造函数 + operator=
	Date(int day, int hour)
	{
		//函数体内初始化
		Time t(hour);//调用Time类的构造函数
		_t = t;
 
		_day = day;
	}
 
private:
	int _day;
	Time _t;
};
 
int main()
{
	Date d(12, 12);
	cout << 4 << endl;
	return 0;
}

这还不如直接使用使用初始化列表初始化呢，还不需要赋值运算符重载函数： 

class Date
{
public:
    //自定义类型，使用初始化列表，只需要构造函数
	Date(int day, int hour)
        :_t(hour)
	{
		_day = day;
	}
 
private:
	int _day;
	Time _t;
};

因此，建议尽量直接使用初始化列表进行初始化。 

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

如下代码，类成员变量中先声明了_a2，再声明了_a1，因此初始化的顺序是先初始化_a2，再初始化_a1：

#include <iostream>
using namespace std;
class A
{
public:
	A(int a)
		: _a1(a)
		, _a2(_a1)
	{}
 
	void Print()
	{
		cout << _a1 << " " << _a2 << endl;
	}
private:
	int _a2;//先声明_a2
	int _a1;//后声明_a1
};
 
int main() {
	A aa(1);
	aa.Print();
}

先声明_a2就会先初始化_a2，用_a1初始化_a2，由于此时_a1还是随机值，因此_a2的值也是随机值，_a1使用a的值1进行初始化，因此，_a1的值为1。

所以，建议类中的成员变量声明的顺序和初始化列表中初始化的顺序一致。

二、explicit关键字 

1.内置类型的隐式转换

int i = 0;
double d = i;//隐式类型转换

c2218a01cec348a79ddd6b6270a217e6.png

 double d = i;并不是将i直接赋值给d，而是用i创建一个临时变量，再把临时变量的值给d，那么d改变的是临时变量的值，而不是i的值，因为程序执行完毕后，i的值并未发生改变。

int i = 0;
const double& d = i;//d引用了临时变量，临时变量具有常性，所以d也必须具有常性

如果d作为引用，那么必须加上const关键字进行修饰，因为d不是i的引用，是临时变量的引用，而临时变量具有常性，不允许引用权限放大。

2.如何避免单参构造函数初始化发生隐式类型转换

正常的类对象初始化如下面的aa1，也可以使用拷贝构造初始化，如aa2。由于c++支持隐式类型转换，因此也支持单参数构造函数初始化，如aa3：

#include<iostream>
using namespace std;
 
class A
{
public :
	A(int a)
		:_a(a)
	{}
 
private:
	int _a;
};
 
int main()
{
	A aa1(1);//构造aa1对象
	A aa2(aa1);//拷贝构造，程序没写拷贝构造，编译器会自动生成拷贝构造函数，对内置类型完成浅拷贝
 
	A aa3 = 3;//单参数的构造函数，会发生隐式类型转换
 
	return 0;
}

那么是如何转换的捏？

A aa3 = 3;

对于自定义类型A，aa3是A类型，3是整形。编译器会先拿A构造一个临时对象temp，3作为参数传给这个临时对象temp，再拿aa3(temp)去拷贝构造，发生隐式类型转换，即先构造，再拷贝构造：

//A aa3 = 3;  
A temp(3);   //先构造
A aa3(temp); //再拷贝构造

不过现在的编译器已经优化过了，会直接调用构造函数A aa(3)。

如果不想让单参数的构造函数发生隐式类型转换，可以使用explicit关键字修饰构造函数，表明该构造函数是显式的，而不是隐式的，就会避免发生不期望的类型转换，使用场景如下：

#include<iostream>
using namespace std;
 
class A
{
public:
	A(int a)
		:_a(a)
	{}
 
private:
	int _a;
};
 
int main()
{
	A aa1(1);//构造aa1对象
	A aa2(aa1);//拷贝构造，程序没写拷贝构造，编译器会自动生成拷贝构造函数，对内置类型完成浅拷贝
 
	A aa3 = 'x';//先拿A构造一个临时对象temp，字符x作为参数传给这个临时对象temp，会发生隐式类型转换，再拿aa3(temp)去拷贝构造
 
	return 0;
}

aa3作为A类的对象，构造时传参应该传int型，但却传了char型，由于发生隐式类型转换，因此编译也没毛病，但是它传参就是不伦不类。这时候可以给A的构造函数加上explicit声明不让该单参构造函数发生隐式类型转换，编译就会报错：

class A
{
public:
	explicit A(int a)
		:_a(a)
	{}
 
private:
	int _a;
};

d162a58772bb487ea028b41ce7ab720c.png

这时候唯一解决办法就是乖乖给aa3传int型参数了。

三、匿名对象

1.匿名对象定义 

没有名字的对象叫做匿名对象，A(3)跟aa1和aa2相比少了个对象名，没有名字，aa1和aa2的生命周期在main函数内，A(3)的生命周期只在当前行：

#include<iostream>
using namespace std;
 
class A
{
public:
	explicit A(int a)
		:_a(a)
	{
		cout << "A(int a):"<< a << endl;
	}
 
	A(const A& aa)
	{
		cout << "A(const A&)" << endl;
	}
 
	~A()
	{
		cout << "~A()" << endl;
	}
 
private:
	int _a;
};
 
int main()
{
	A aa1(1);//生命周期在main函数内
	A aa2(aa1);//生命周期在main函数内
 
	A(3);//构造匿名对象，生命周期只在这一行
 
	return 0;
}

F10调试：当执行完A(3)还没执行return 0时，aa1和aa2的生命周期还没有结束，不会调用析构函数，此时打印的析构函数只能是匿名对象A(3)的析构函数：c3131b5b2f3d421eab4ae61ef216e212.png

 所以A(3)这一行执行完就调析构函数了。

2.匿名对象应用场景

假设有一个函数f，且A类的构造函数全缺省：

#include<iostream>
using namespace std;
 
class A
{
public:
	A(int a = 0)//构造函数全缺省
		:_a(a)
	{
		cout << "A(int a):"<< a << endl;
	}
 
	A(const A& aa)
	{
		cout << "A(const A&)" << endl;
	}
 
	~A()
	{
		cout << "~A()" << endl;
	}
 
	void f()//f函数
	{
		cout << "f()" << endl;
	}
 
private:
	int _a;
};
 
int main()
{
	A aa1(1);//生命周期在main函数内
	A aa2(aa1);//生命周期在main函数内
 
	A(3);//构造匿名对象，生命周期只在这一行
 
	return 0;
}

调用f()函数时，需要定义一个A类对象，才能调用A类函数f，这就需要写两行：

int main()
{
	A aa1(1);//生命周期在main函数内
	A aa2(aa1);//生命周期在main函数内
 
	A(3);//构造匿名对象，生命周期只在这一行
 
	A aa4;//需要定义一个A类对象，才能调用f
	aa4.f();
 
	return 0;
}

对象aa4 在main函数结束后才会销毁。如果定义对象只是为了调用函数，那么可以考虑直接定义一个匿名对象：

int main()
{
	A aa1(1);//生命周期在main函数内
	A aa2(aa1);//生命周期在main函数内
 
	A(3);//构造匿名对象，生命周期只在这一行
 
	A aa4;//需要定义一个A类对象，才能调用f
	aa4.f();
 
    A().f();//定义匿名对象来调用函数f()
 
	return 0;
}

这个匿名对象就是为了调用函数f，这个匿名对象后边也没人用它，在当前行调用完f()函数就销毁了。

Static成员

概念：

声明为static的类成员叫做类的静态成员，分为两种：

（1）静态成员变量：用static修饰的成员变量

（2）静态成员函数：用static修饰的成员函数

一、静态成员变量 

如何计算A定义了多少个对象？

#include<iostream>
using namespace std;
 
class A
{
private:
	static int _n;//仅仅只是声明，_n存在于静态区，属于整个类，也属于类的所有对象
};
 
int main()
{
	A a1;
	A a2;
	A();
 
    return 0;
}

所有对象要么是构造出来的，要么是拷贝构造出来的，因此要声明一个全局的成员变量，生命周期也必须是全局的，那么生命周期被改变了，这个成员变量就需要用static进行修饰，即静态成员变量，static int _n;

1.静态成员变量必须在类外定义和初始化的原因

那么如何对_n进行定义初始化呢？如果在类内初始化，会导致每个对象都包含该静态成员。静态成员变量必须在类外定义和初始化的原因：

（1）声明不分配内存，定义会分配内存，如果在类内定义静态成员变量，那么每个对象初始化时都要为静态成员变量分配一块空间，会造成重复定义。

（2）静态成员和类处于同一级别，普通成员和对象处于同一级别。 类级别的成员，应先于类对象的存在而存在，且静态成员变量应被所有类对象共享，所以静态成员变量不能放在类内当对象初始化时才初始化。

如何在类外定义和初始化？虽然是私有静态成员变量，但是不受访问限定符限制：
 

#include<iostream>
using namespace std;
 
class A
{
public:
    A()//构造函数
	{
		++_n;
	}
 
	A(const A& a)//拷贝构造函数
	{
		++_n;
	}
private:
	static int _n;//n存在于静态区，属于整个类，不属于某个对象
};
 
//静态成员变量不受访问限定符限制，否则就没办法初始化了；声明时已经加了static，这里不需要再加static
int A::_n = 0;//在全局指定类域为A，并把值初始化为1
 
int main()
{
	A a1;
	A a2;
	A();
 
    return 0;
}

现在只需要获取_n的值就可以了，它是私有的，我们获取不了。

2.如何在类外面访问静态成员变量

有两种方式可以在类外面访问静态成员变量：

（1）修改静态成员变量的访问限定符，注掉private，就可以在类外获取_n的值：

①类名::静态成员变量

②对象.静态成员变量

#include<iostream>
using namespace std;
 
class A
{
public:
	A()//构造函数
	{
		++_n;
	}
 
	A(const A& a)//拷贝构造函数
	{
		++_n;
	}
 
//private:
	static int _n;//n存在于静态区，属于整个类，不属于某个对象
};
 
int A::_n = 0;
 
int main()
{
	A a1;
	A a2;
	A();
 
	//这三行访问的都是全局的_n，因此打印结果都一样，都是3
    cout << A::_n << endl;//类名::静态成员变量
	cout << a1._n << endl;//对象.静态成员变量
	cout << a2._n << endl;//对象.静态成员变量
}

（2）在类外面访问要看访问限定符：如果这个静态成员变量_n就是私有的，在类外面无法访问，需要定义一个公有的成员函数访问静态成员变量，通过对象调用成员函数获取_n的值：

#include<iostream>
using namespace std;
 
class A
{
public:
	A()//构造函数
	{
		++_n;
	}
 
	A(const A& a)//拷贝构造函数
	{
		++_n;
	}
 
	//获取静态成员变量的值
	int getN()
	{
		return _n;
	}
 
private:
	static int _n;//n存在于静态区，属于整个类，不属于某个对象
};
 
int A::_n = 0;
 
int main()
{
	A a1;
	A a2;
 
	//这两行访问的都是全局的_n，因此打印结果都一样，都是3
	cout << A().getN() << endl;
	cout << a1.getN() << endl;
	cout << a2.getN() << endl;
}

二、静态成员函数 

静态成员函数跟普通函数区别：没有this指针，不能访问非静态成员。能访问静态成员是由于静态成员属于整个类，只要突破类域就能访问，突破类域有两种方式：

（1）对象可以帮助静态成员突破类域

（2）指定静态成员的类

因此一般定义一个静态成员函数来访问静态成员变量。

#include<iostream>
using namespace std;
 
class A
{
public:
	A()//构造函数
	{
		++_n;
	}
 
	A(const A& a)//拷贝构造函数
	{
		++_n;
	}
 
    //静态成员函数，没有this指针，不能访问非静态成员
	static int GetN()
	{
		//_a = 1;//不能访问非静态成员
		return _n;
	}
 
private:
	static int _n;//n存在于静态区，属于整个类，不属于某个对象
	int _a;
};
 
int A::_n = 0;
 
int main()
{
	A a1;
	A a2;
	
	//这三行访问的都是全局的_n，因此打印结果都一样
    cout << A().GetN() << endl;//匿名对象可以帮助静态成员突破类域
	cout << a1.GetN() << endl;//对象可以帮助静态成员突破类域
	cout << A::GetN() << endl;//指定静态成员的类，让编译器到类里面去找
 
}

三、static成员特性

1. 静态成员为所有类对象所共享，不属于某个具体的对象实例
2. 静态成员变量必须在类外定义，定义时不添加static关键字
3. 类静态成员可用类名::静态成员来访问，也可以用对象.静态成员来访问
4. 静态成员函数没有隐藏的this指针，不能访问任何非静态成员
5. 静态成员和类的普通成员一样，也有public、protected、private3种访问级别，也可以有返回值

6. 普通成员只能通过对象访问，不能通过类名访问。
7. 静态成员函数与普通成员函数的根本区别在于：普通成员函数有 this 指针，可以访问类中的任意成员；而静态成员函数没有 this 指针，只能访问静态成员（包括静态成员变量和静态成员函数）

a篇博客就溜
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java双括弧初始化操作技巧
09-03
这种技术通过创建一个匿名内部类，并在其内部使用实例初始化块来填充集合对象，从而提高了代码的简洁性和可读性。 在传统的Java代码中，初始化一个集合对象通常涉及以下步骤： 1. 定义一个集合类型的变量。 2. 创建...
java代码-初始化时，把三个成员变量全部设置为10
07-15
在Java编程语言中，初始化成员变量是程序设计的基础部分，特别是在创建类或对象时。当一个类被实例化或者对象被创建时，我们通常希望某些字段（成员变量）具有特定的初始值。在这个场景中，标题和描述指出的“初始化...
用匿名对象，函数以值返回的局部对象初始化对象
weizz1990的博客
04-07 599
用匿名对象，函数以值返回的局部对象初始化对象
面向对象 成员变量 匿名对象
逍遥单机君
09-25 520
面向对象
匿名对象使用方法
chen404897439的博客
06-05 1774
package cn.dali.code06; import java.util.Scanner; /*普通创建对象格式： * 类名称 对象名称 = new 类名称(); * * 匿名对象创建格式： * new 类名称(); * * 匿名对象成员变量或者方法调用格式: * new 类名称().成员变量或者方法 * * 注意： * 匿名对象只能使用一次，下一次使用需重新创建新...
const/static修饰成员函数+初始化列表
lzf的博客
05-12 907
初始化列表+static/const修饰成员函数，友元函数、内部类，匿名对象，编译器对于连续构造的优化
C++类和对象(下)——初始化列表、static成员和友元
03-10 7823
C++类和对象——初始化列表、static成员和友元一、再谈构造函数1.1 构造函数整体赋值1.2 初始化列表三级目录 关于C++类和对象的学习 C++类和对象(上)——类的基本概念、类的限定符及封装和类成员函数的this指针 C++类和对象(中)——类的6个默认成员函数(构造、析构、拷贝构造、赋值运算符重载) 一、再谈构造函数 1.1 构造函数整体赋值 在创建对象时，编译器通过调用构造函数，给对象中各个成员变量一个合适的初始值。例如我们之前创建的Date类 class Date { public: D
【C++初阶】类和对象（下）构造函数（初始化列表） + explicit关键字 + static成员 + 友元 + 内部类 + 匿名对象
Weraphael的博客
05-24 813
构造函数之初始化列表 + explicit关键字 + static成员笔记总结
【C++】初始化列表、匿名对象、static成员、友元、内部类
炸掉地球的博客
06-23 1101
实际上，构造函数的函数体内，并不是对 对象 初始化的地方，而是对成员变量进行赋值。因为初始化只能初始化一次，而构造函数体内可以多次赋值。真正进行初始化的地方是初始化列表（在创建类变量时，初始化列表将成员变量直接初始化为括号内的表达式值）
C++：初始化列表，static成员，友元，内部类
li209779的博客
09-16 742
本篇博客作为C++：初始化列表，static成员，友元，内部类的知识总结。以上就是我对于初始化列表，static成员，友元，内部类，匿名对象的知识总结。！！
【C++】初始化列表、隐式转换、static成员、友元与匿名对象
weixin_69380220的博客
05-30 1185
初始化列表、隐式转换
【C++入门到精通】C++入门 —— 类和对象（初始化列表、Static成员、友元、内部类、匿名对象）
Yawesh的博客
07-31 2205
这篇文章探讨了C++中的几个重要概念：初始化列表、静态成员、友元和匿名对象，这篇文章涵盖了一些重要的C++概念，对于理解和应用这些概念有很大帮助。
委托的简单实例 delegate 委托 匿名方法 自动属性 集合初始化器 类初始化器
10-21
最后是"类初始化器"，也称为对象初始化器，它允许我们在创建对象的同时设置其成员的初始值。比如： ```csharp var myClass = new MyClass { AutoProperty = 10 }; ``` 总结来说，这些特性大大提高了C#的可读性和...
13_Java面向对象_第5天（static、final、匿名对象、内部类、包、修饰符、代码块）_讲义
02-16
本讲义主要涵盖了Java中的几个核心概念，包括`static`、`final`、匿名对象、内部类、包、修饰符以及代码块。下面将逐一详细阐述这些知识点。 1. **`static`关键字**： `static`关键字在Java中用于声明类级别的变量...
JAVA中使用双括号来初始化静态常量的小技巧
09-04
在这个例子中，我们创建了一个`Map`类型的静态常量`DATA`，然后在类的静态初始化块（`static`块）中添加了具体的初始化操作，如放入键值对。这种做法很常见，但代码分布于两个不同的位置，可能会影响代码的整洁度。 ...
C语言 之 理解指针（1）
fallzzzzz的博客
07-20 1114
就是先获取该数组的首元素的地址，从前面我们知道，指针的类型的作用是指针+1 所跳过的字节数，int为整形，大小为4个字节，所以p+1就跳过4个字节，p+2就跳过8个字节，计算机的CPU（中央处理器）在处理数据的时候，需要的数据是在内存中读取的，处理后数据也会放回内存中，如果想对这些空间进行高效的管理，就可以。并且我们知道，数组的元素存放是随着下标增长，内存地址变大的。上面的代码创建了一个整型变量n，因为一个整形的大小是4个字节，所以内存中申请了4个字节，⽤于存放整数10，其中每个字节都有地址。
C++二叉搜索树
Jk_Mr的博客
07-20 1118
树结构是一种重要的数据结构。树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。
C++笔试强训7
m0_74189279的博客
07-21 961
这意味着编译器会尝试将函数的代码直接插入到每个调用该函数的地方，而不是像通常那样进行函数调用（即，生成调用指令，跳转到函数代码，执行函数体，然后返回）。友元函数是在类外部定义的普通函数，它只能通过传入的参数（如果有的话）来访问类的成员，或者通过类的对象显式地访问（如果该函数设计为接受类的对象作为参数）。函数参数默认值又叫缺省参数，缺省参数必须从右向左开始缺省，必须连续给定缺省值，也就是说，从左到右，一旦遇到一个参数是缺省的，那么之后的参数也必须都是缺省的。指针是类成员函数特有的，用于指向调用该函数的对象。
商品信息管理系统(C语言)
最新发布
zeyeqianli的博客
07-22 305
该案例使用了C语言中最具特色的结构体，将每个商品的所有信息存在结构体中，并且定义一个结构体类型的数组保存所有商品的信息，并且按照模块化的编程思想，将要实现的每个功能编写成独立的函数，这样即方便阅读同时也方便差错修改。该系统的主要功能如下：(1) 登录系统。(2) 创建商品信息。(3) 打印商品信息。(4) 查询商品信息。(5) 修改商品信息。(6) 删除商品信息。(7) 商品价格排名显示。(8) 退出系统。
Java中的static：静态方法与静态初始化块
"Java 中的 static 使用、静态方法、静态初始化块、封装和内部类" 在Java编程语言中，`static`关键字有着重要的作用，它不仅用于声明静态变量，还可以修饰方法和初始化块。让我们详细了解一下这些概念。 首先，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值