网站首页制作代码,免费书画网站模板,怎样换网站关键词,2个网站 同意内容 百度优化前言 在谈论C时#xff0c;常常会涉及到一些高级特性和概念#xff0c;比如初始化列表、static成员、友元、内部类、匿名对象等。这些概念在C编程中起着非常重要的作用#xff0c;对于想要深入了解C语言的开发者来说#xff0c;掌握这些知识是至关重要的。本文#xff0c;…前言 在谈论C时常常会涉及到一些高级特性和概念比如初始化列表、static成员、友元、内部类、匿名对象等。这些概念在C编程中起着非常重要的作用对于想要深入了解C语言的开发者来说掌握这些知识是至关重要的。本文我们将深入探讨这些概念探讨它们的作用以及如何在实际中的应用。 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;
}; 这是最开始所说的构造函数初始化的一种方法这种方法实质上不能被成为初始化构造函数体中的语句只能将其称为赋初值初始化只能初始化一次而构造函数体内可以多次赋值。 回到初始化列表。 初始化列表以一个冒号开始逗号分割每个 成员变量 后面跟一个放在括号中的初始值或表达式。 比如
class Date
{
public:Date(int year, int month, int day): _year(year), _month(month), _day(day){}
private:int _year;int _month;int _day;
}; 定义一个类的对象时是这样的
Date d1(2023,11,20);
这是对象的整体定义成员变量的定义在哪儿就是在初始化列表。
每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)。
对于一些特殊情况就必须要使用初始化列表进行初始化
引用成员变量const成员变量自定义类型成员(且该类没有默认构造函数时) 初始化列表也可以与构造函数函数体内初始化结合使用 这个是一个测试样例
class A
{
public:A(int a):_a(a){}
private:int _a;
};Date(int year, int month, int day)
{_year year;_month month;_day day;_n 1; //报错error C2530: “Date::_ref”: 必须初始化引用_ref year; //报错error C2789: “Date::_n”: 必须初始化常量限定类型的对象
}
private:int _year;int _month;int _day;int _ref;const int _n;}; _ref和_n如果在函数体内初始化就会报错const修饰会让其具备常属性也就是说该变量只能在定义时初始化引用类型也是在定义时必须要初始化。 正确的构造函数写法应该是
Date(int year, int month, int day): _n(1), _ref(_year)
{_year year;_month month;_day day;
} 接下来就是它在C语法设计时的细节问题
class Date
{
public:Date(int year, int month, int day): _n(1) //类成员定义, _ref(year){_year year;_month month;_day day;}
private:int _year;int _month;int _day;int _ref;const int _n;
};int main()
{Date d1(2023, 11, 20);// 对象整体定义return 0;
} 这里C语法设计的有点过于复杂构造函数执行完初始化列表内容之后函数体内的成员变量也已经被定义 在没有执行赋值初始化操作之前内置类型默认的随机值但此时的全部成员变量都是已经被定义了的。
其次就是自定义类型
测试代码比如
class A
{
public:A(int a 0) //注意这里给了缺省值:_a(a){}
private:int _a;
};class Date
{
public:Date(int year, int month, int day): _n(1), _ref(year){_year year;_month month;_day day;}
private:int _year;int _month;int _day;int _ref;const int _n;A _obj;
};int main()
{Date d1(2023, 11, 20);return 0;
} 注意观察以下调试过程 在初始化列表进行初始化时自定义类型会自动调用默认构造函数。
注意自定义类型A在构造函数中给了缺省值 如果不给缺省值就会直接报错没有默认构造函数 error C2512: “A”: 没有合适的默认构造函数可用 解决方法有两种
在A的构造函数中给缺省值使用初始化列表
Date(int year, int month, int day): _n(1), _ref(year), _obj(10)
{_year year;_month month;_day day;
} 之前我们提到C打补丁支持声明时给缺省值
class Date
{
public:Date(int year, int month, int day): _n(1), _ref(year), _obj(10){_year year;_month month;_day day;}
private:int _year 1; //在声明中给缺省值int _month;int _day;int _ref;const int _n;A _obj;
};
这个缺省值其实就是给初始化列表的在初始化列表中如果没有显示要求初始化就会使用这里的缺省值。 尽量使用初始化列表初始化因为不管你是否使用初始化列表对于自定义类型成员变量一定会先使用初始化列表初始化 当然也有初始化列表无法完成的情况
有些初始化或检查的任务初始化列表无法完成比如
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;
}; 使用函数初始化数组的值或者是开空间失败后的异常处理。
成员变量在类中声明次序就是其在初始化列表中的初始化顺序与其在初始化列表中的先后次序无关 看以下这个代码
class A
{
public:A(int a):_a1(a), _a2(_a1){}void Print() {cout _a1 _a2 endl;}
private:int _a2;int _a1;
};int main()
{A aa(1);aa.Print();
} 它的输出结果是什么
答案是_a1 1和_a2 随机值声明次序就是其在初始化列表中的初始化顺序。所以它先初始化的是_a2_a2使用_a1的值进行初始化但此时_a1还未执行初始化此时的_a1为随机值。
1.2 explicit关键字
看下面这段代码
class A
{
public:A(int a):_a(a){}int _a 0;};
void Test()
{A a1(1);A a2 2;// 内置类型隐式转换成自定义类型} a2在进行初始化时发生了隐式转换实际编译器背后会用2构造一个无名对象最后用无名对象给a2对象进行赋值。 能支持整形2转换是有A的int 单参数构造函数支持如果使用int* 类型就不支持隐式类型转换了。
想要支持可以添加一个含int* 的单参数构造函数
class A
{
public:A(int a):_a(a){}A(int* p){}int _a 0;}; 如果不想让这个隐式类型转换强制类型转换还是可以的就可以使用explicit关键字来修饰构造函数。
class A
{
public:explicit A(int a):_a(a){}int _a 0;}; 前边的示例是单参数那多参数呢
class Date
{
public:Date(int year, int month 1, int day 1): _year(year), _month(month), _day(day){}private:int _year;int _month;int _day;
}; 如上也是可以的支持一个传参的半缺省全缺省也可以也是可以隐式类型转换。那可不可以支持多个内置类型隐式转换C11是可以的
Date d1 { 2023, 11, 10 }; 但是只能如上这种写法。 多参数也是一样如果不想要隐式类型转换可以给构造函数加explicit。
2. static成员 static修饰有什么作用
static修饰的成员变量或成员函数在类加载时执行并且只会执行一次。 问题实现一个类计算程序中创建出了多少个类对象 使用全局变量计算
int n 0;class A
{
public:A() { n; }A(const A t) { n; }~A() {}private:};A func()
{A aa;return aa;
}int main()
{n;A aa;func();n;cout n endl;return 0;
}
当前边存在修改n的情况结果就不准确了其次就是每次使用时都要将n置为0其他类也可能使用过n那有没有专属这个类的计数变量呢使用static就可以很好的解决这个问题。
2.1 概念
用static修饰的成员变量称之为静态成员变量
用static修饰的成员函数称之为静态成员函数。
静态成员变量一定要在类外进行初始化
class A
{
public:A() { count; }A(const A t) { count; }~A() {}static int GetACount() { return count; }
private:static int count;
};int A::count 0;
A func()
{A aa;return aa;
}int main()
{A aa;func();cout A::GetACount() endl;return 0;
} 2.2 特点 静态成员为所有类对象所共享不属于某个具体的对象存放在静态区 静态成员变量必须在类外定义定义时不添加static关键字类中只是声明 类静态成员即可用 类名::静态成员 或者 对象.静态成员 来访问 静态成员函数没有隐藏的this指针不能访问任何非静态成员 静态成员也是类的成员受public、protected、private 访问限定符的限制
总结静态成员变量和静态成员函数可以理解为受限制的全局变量和全局函数。专属于某个类受类域和访问限定符的限制。 3. 匿名对象
匿名对象其实很简单我们看下面这个代码
class Date
{
public:Date(int year, int month 1, int day 1): _year(year), _month(month), _day(day){}private:int _year;int _month;int _day;
};int main()
{vectorDate v;Date d1(2023, 11, 1);v.push_back(d1);return 0;
}
在C中的STL容器中我们要存储日期类的对象。每次存储还要创建一个对象然后再存储这样很麻烦这里我们就可以使用匿名函数
v.push_back(Date(2023, 10, 31));
匿名对象在这样场景下就很好用。匿名对象的生命周期只有这一行执行完之后自动调用析构函数。
4. 友元 友元提供了一种突破封装的方式有时提供了便利。但是友元会增加耦合度破坏了封装所以 友元不宜多用
友元分为友元函数和友元类 4.1 友元函数 友元函数可以直接访问类的私有成员它是定义在类外部的普通函数不属于任何类但需要在类的内部声明声明时需要加friend关键字 前边在实现Date类的流插入、流提取中提到过。
友元函数的特点
友元函数可访问类的私有和保护成员但不是类的成员函数友元函数不能用const修饰友元函数可以在类定义的任何地方声明不受类访问限定符限制一个函数可以是多个类的友元函数友元函数的调用与普通函数的调用原理相同 4.2 友元类 友元类friend class是指一个类可以访问另一个类的私有成员和保护成员。
比如
class A {
private:int privateData;
protected:int protectedData;friend class B; // B是A的友元类
};class B {
public:void accessA(A a) {// 友元类B可以访问A的私有成员和保护成员a.privateData 10;a.protectedData 20;}
};注意
友元关系是单向的
比如类A声明类B为友元类那么类B可以访问类A的私有成员和保护成员但类A不能访问类B的私有成员和保护成员。
友元关系不能传递
如果C是B的友元 B是A的友元则不能说明C时A的友元
友元关系不能继承 5. 内部类
什么是内部类
一个类定义在另一个类的内部 内部类是一个独立的类它不属于外部类更不能通过外部类的对象去访问内部类的成员。外部类对内部类没有任何优越的访问权限 比如
class A
{
private:int h;
public:class B // B天生就是A的友元{public:void fun(const A a){cout a.h endl;//OK}};
}; A于B的关系
可以理解为B就是一个普通类它只受A的类域和访问限定符限制
int main()
{A aa;//B bb //error C2065: “B”: 未声明的标识符A::B bb;cout sizeof(A) endl; // 4return 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;
};int main()
{A aa1 1; return 0;
}
A aa1 1;
它的过程是什么样的它的过程其实分为两步
1、先用1构造一个临时对象 2、再用临时对象拷贝构造aa1 但我们在调试时会发现最终编译器显示的是一次构造。这其实就是由于编译器的优化。 同一个表达式中连续构造构造 / 构造拷贝构造 / 拷贝构造拷贝构造 会合二为一 合并规则如下
构造构造-构造构造拷贝构造-构造拷贝构造拷贝构造-拷贝构造 编译器不同优化效果也不同老的编译器不会怎么优化但新的编译器基本都会做这样的优化甚至优化的比这个更厉害。 总结 在C编程中掌握初始化列表、static成员、友元和内部类等相关知识是非常重要的。这些概念不仅能够帮助我们更好地理解C语言的特性还能够提高我们的编程效率和代码质量以上便是本文全部内容希望可以对你有所帮助感谢阅读
