建设银行网站打不开别的网站可以用吗多语言网站一个域名

建设银行网站打不开别的网站可以用吗,多语言网站一个域名,茂名seo网站推广,做网站htmlstatic成员 ⽤static修饰的成员变量#xff0c;称之为静态成员变量#xff0c;静态成员变量⼀定要在类外进⾏初始化。静态成员变量为所有类对象所共享#xff0c;不属于某个具体的对象#xff0c;不存在对象中#xff0c;存放在静态区。⽤static修饰的成员函数#xff0…static成员⽤static修饰的成员变量称之为静态成员变量静态成员变量⼀定要在类外进⾏初始化。静态成员变量为所有类对象所共享不属于某个具体的对象不存在对象中存放在静态区。⽤static修饰的成员函数称之为静态成员函数静态成员函数没有this指针。静态成员函数中可以访问其他的静态成员但是不能访问⾮静态的因为没有this指针。⾮静态的成员函数可以访问任意的静态成员变量和静态成员函数。突破类域就可以访问静态成员可以通过类名::静态成员或者对象.静态成员来访问静态成员变量和静态成员函数。静态成员也是类的成员受public、protected、private访问限定符的限制。静态成员变量不能在声明位置给缺省值初始化因为缺省值是个构造函数初始化列表的静态成员变量不属于某个对象不⾛构造函数初始化列表。// 实现⼀个类计算程序中创建出了多少个类对象 #includeiostream using namespace std; class A { public: A() { _scount; } A(const A t) { _scount; } ~A() { --_scount; } static int GetACount() { return _scount; } private: // 类⾥⾯声明 static int _scount; }; // 类外⾯初始化 int A::_scount 0; int main() { cout A::GetACount() endl; A a1, a2; A a3(a1); cout A::GetACount() endl; cout a1.GetACount() endl; // 编译报错error C2248: “A::_scount”: ⽆法访问 private 成员(在“A”类中声明) //cout A::_scount endl; return 0; }如果不实例化对象需要计算count//A aa;有名对象 A aa; //为了调用而创建的所以要-1 cout aa.GetCount()-1 endl; //A() 这种写法叫匿名对象生命周期只在这一行 cout A().GetCount()-2 endl;方法3是使用静态成员函数没有this指针静态成员变量和静态成员函数本质受限制的全局变量和全局函数专属这个类受类域和访问限定符的限制求123…n_牛客题霸_牛客网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 arr[n]; return Sum::GetRet(); } };静态成员函数不可以调用非静态成员函数也不能访问非静态成员变量静态成员函数没有this指针非静态成员函数可以调用类的静态成员函数友元友元提供了⼀种突破类访问限定符封装的⽅式友元分为友元函数和友元类在函数声明或者类声明的前⾯加friend并且把友元声明放到⼀个类的⾥⾯。外部友元函数可访问类的私有和保护成员友元函数仅仅是⼀种声明他不是类的成员函数。友元函数可以在类定义的任何地⽅声明不受类访问限定符限制。⼀个函数可以是多个类的友元函数。友元类中的成员函数都可以是另⼀个类的友元函数都可以访问另⼀个类中的私有和保护成员。友元类的关系是单向的不具有交换性⽐如A类是B类的友元但是B类不是A类的友元。友元类关系不能传递如果A是B的友元B是C的友元但是A不是C的友元。有时提供了便利。但是友元会增加耦合度破坏了封装所以友元不宜多⽤。#includeiostream using namespace std; // 前置声明都则A的友元函数声明编译器不认识B class B; class A { // 友元声明 friend void func(const A aa, const B bb); private: int _a1 1; int _a2 2; }; class B { // 友元声明 friend void func(const A aa, const B bb); private: int _b1 3; int _b2 4; }; void func(const A aa, const B bb) { cout aa._a1 endl; cout bb._b1 endl; } int main() { A aa; B bb; func(aa, bb); return 0; }#includeiostream using namespace std; class A { // 友元声明 friend class B; private: int _a1 1; int _a2 2; }; class B { public: void func1(const A aa) { cout aa._a1 endl; cout _b1 endl; } void func2(const A aa) { cout aa._a2 endl; cout _b2 endl; } private: int _b1 3; int _b2 4; }; int main() { A aa; B bb; bb.func1(aa); bb.func1(aa); return 0; }内部类如果⼀个类定义在另⼀个类的内部这个内部类就叫做内部类。内部类是⼀个独⽴的类跟定义在全局相⽐他只是受外部类类域限制和访问限定符限制所以外部类定义的对象中不包含内部类。内部类默认是外部类的友元类。内部类本质也是⼀种封装当A类跟B类紧密关联A类实现出来主要就是给B类使⽤那么可以考虑把A类设计为B的内部类如果放到private/protected位置那么A类就是B类的专属内部类其他地⽅都⽤不了。#includeiostream using namespace std; class A { private: static int _k; int _h 1; public: class B // B默认就是A的友元 { public: void foo(const A a) { cout _k endl; //OK cout a._h endl; //OK } int _b1; }; }; int A::_k 1; int main() { cout sizeof(A) endl; A::B b; A aa; b.foo(aa); return 0; }求123…n_牛客题霸_牛客网class Solution { // 内部类 class Sum { public: Sum() { _ret _i; _i; } }; static int _i; static int _ret; public: int Sum_Solution(int n) { // 变⻓数组 Sum arr[n]; return _ret; } }; int Solution::_i 1; int Solution::_ret 0;匿名对象⽤类型(实参)定义出来的对象叫做匿名对象相⽐之前我们定义的类型对象名(实参)定义出来的叫有名对象匿名对象⽣命周期只在当前⼀⾏⼀般临时定义⼀个对象当前⽤⼀下即可就可以定义匿名对象。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; } }; int main() { A aa1; // 不能这么定义对象因为编译器⽆法识别下⾯是⼀个函数声明还是对象定义 //A aa1(); // 但是我们可以这么定义匿名对象匿名对象的特点不⽤取名字 // 但是他的⽣命周期只有这⼀⾏我们可以看到下⼀⾏他就会⾃动调⽤析构函数 A(); A(1); A aa2(2); // 匿名对象在这样场景下就很好⽤当然还有⼀些其他使⽤场景这个我们以后遇到了再说 Solution().Sum_Solution(10); return 0; }对象拷⻉时的编译器优化现代编译器会为了尽可能提⾼程序的效率在不影响正确性的情况下会尽可能减少⼀些传参和传返回值的过程中可以省略的拷⻉。如何优化C标准并没有严格规定各个编译器会根据情况⾃⾏处理。当前主流的相对新⼀点的编译器对于连续⼀个表达式步骤中的连续拷⻉会进⾏合并优化有些更新更激进的编译器还会进⾏跨⾏跨表达式的合并优化。linux下可以将下⾯代码拷⻉到test.cpp⽂件编译时⽤g test.cpp -fno-elideconstructors的⽅式关闭构造相关的优化。#includeiostream using namespace std; class A { public: A(int a 0) :_a1(a) { cout A(int a) endl; } A(const A aa) :_a1(aa._a1) { cout A(const A aa) endl; } A operator(const A aa) { cout A operator(const A aa) endl; if (this ! aa) { _a1 aa._a1; } return *this; } ~A() { cout ~A() endl; } private: int _a1 1; }; void f1(A aa) {} A f2() { A aa; return aa; } int main() { // 传值传参 // 构造拷⻉构造 A aa1; f1(aa1); cout endl; // 隐式类型连续构造拷⻉构造-优化为直接构造 f1(1); // ⼀个表达式中连续构造拷⻉构造-优化为⼀个构造 f1(A(2)); cout endl; cout *********************************************** endl; // 传值返回 // 不优化的情况下传值返回编译器会⽣成⼀个拷⻉返回对象的临时对象作为函数调⽤表达式的返回值 // ⽆优化 vs2019 debug // ⼀些编译器会优化得更厉害将构造的局部对象和拷⻉构造的临时对象优化为直接构造vs2022 debug f2(); cout endl; // 返回时⼀个表达式中连续拷⻉构造拷⻉构造-优化⼀个拷⻉构造 vs2019 debug // ⼀些编译器会优化得更厉害进⾏跨⾏合并优化将构造的局部对象aa和拷⻉的临时对象和接收返回值对象aa2优化为⼀个直接构造。vs2022 debug A aa2 f2(); cout endl; // ⼀个表达式中开始构造中间拷⻉构造赋值重载-⽆法优化vs2019 debug // ⼀些编译器会优化得更厉害进⾏跨⾏合并优化将构造的局部对象aa和拷⻉临时对象合 并为⼀个直接构造vs2022 debug aa1 f2(); cout endl; return 0; }void func(A aa1) { } A aa1(1); //构造 A aa2(aa1); //拷贝构造 A aa3 aa1; //拷贝构造赋值拷贝 aa2 aa3 //赋值拷贝 //拷贝构造 func(aa); //构造拷贝构造构造 func(A(2)); //拷贝构造构造构造 func(3);同一个表达式中构造构造-构造构造拷贝构造-构造拷贝构造拷贝构造-拷贝构造