电脑交换式登录初始化进程失败,交互式登录初始化失败怎么解决

首页 > 经验 > 作者：YD1662024-04-01 01:41:47

1 const 类成员初始化

(a) 成员只有 const, 类似引用, 需要在初始列表进行初始化(特殊情况C 11特性, 如果是整数(char, short, int), 可以直接在声明处赋值)。

(b) 成员既有 const 又有 static, 按照 static 初始化方式。


  2. #include <iostream>
  3. #include <stdio.h>
  4. using namespace std;
  6. class MyTest
  7. {
  8. public:
  10. MyTest():
  11. m_ConstString("My Test !!!")
  12. {
  15. }
  17. void printMyTest()
  18. {
  20. std::cout << "m_ConstVarInt=" << m_ConstVarInt << endl;
  21. std::cout << "m_ConstString=" << m_ConstString << endl;
  22. std::cout << "mStaticConstVarInt=" << mStaticConstVarInt << endl;
  23. }
  26. private:
  27. const int m_ConstVarInt = 100; // 成员只有 const, 特殊情况C 11特性, non-static data member initializers only available with -std=C 11 or -std=gnu 11
  28. const std::string m_ConstString; // 成员只有 const
  29. static const int mStaticConstVarInt; //成员既有 const 又有 static
  30. };
  32. const int MyTest::mStaticConstVarInt = 1000;
  35. int main()
  36. {
  37. MyTest test;
  39. test.printMyTest();
  41. return 0;
  42. }

程序运行结果:


  2. m_ConstVarInt=100
  3. m_ConstString=My Test !!!
  4. mStaticConstVarInt=1000

2. const 重载

类中函数只有 const 属性不同, 可以进行函数重载(注意, 普通函数不可以)


  2. #include <iostream>
  3. #include <stdio.h>
  4. using namespace std;
  6. class MyTest
  7. {
  8. public:
  10. MyTest():
  11. m_ConstString("My Test !!!")
  12. {
  15. }
  17. void printMyTest()
  18. {
  19. std::cout << "printMyTest !!!!!" << endl;
  20. std::cout << "m_ConstVarInt=" << m_ConstVarInt << endl;
  21. std::cout << "m_ConstString=" << m_ConstString << endl;
  22. std::cout << "mStaticConstVarInt=" << mStaticConstVarInt << endl;
  23. }
  25. void printMyTest() const
  26. {
  27. std::cout << "printMyTest const !!!!!" << endl;
  28. std::cout << "m_ConstVarInt=" << m_ConstVarInt << endl;
  29. std::cout << "m_ConstString=" << m_ConstString << endl;
  30. std::cout << "mStaticConstVarInt=" << mStaticConstVarInt << endl;
  31. }
  34. private:
  35. const int m_ConstVarInt = 100; // 成员只有 const, 特殊情况C 11特性, non-static data member initializers only available with -std=c 11 or -std=gnu 11
  36. const std::string m_ConstString; // 成员只有 const
  37. static const int mStaticConstVarInt; // 成员既有 const 又有 static
  38. };
  40. const int MyTest::mStaticConstVarInt = 1000;
  43. int main()
  44. {
  45. const MyTest testConst;
  47. //访问重载的const成员
  48. testConst.printMyTest();
  50. MyTest test;
  52. //访问重载的非const成员
  53. test.printMyTest();
  55. return 0;
  56. }

程序运行结果:


  2. printMyTest const !!!!!
  3. m_ConstVarInt=100
  4. m_ConstString=My Test !!!
  5. mStaticConstVarInt=1000
  6. printMyTest !!!!!
  7. m_ConstVarInt=100
  8. m_ConstString=My Test !!!
  9. mStaticConstVarInt=1000

3 const 类对象

const 类对像只能访问 const 成员


  2. #include <iostream>
  3. #include <stdio.h>
  4. using namespace std;
  6. class MyTest
  7. {
  8. public:
  10. MyTest():
  11. m_ConstString("My Test !!!")
  12. {
  15. }
  17. void printMyTest()
  18. {
  19. std::cout << "printMyTest !!!!!" << endl;
  20. std::cout << "m_ConstVarInt=" << m_ConstVarInt << endl;
  21. std::cout << "m_ConstString=" << m_ConstString << endl;
  22. std::cout << "mStaticConstVarInt=" << mStaticConstVarInt << endl;
  23. }
  25. void printMyTest() const
  26. {
  27. std::cout << "printMyTest const !!!!!" << endl;
  28. std::cout << "m_ConstVarInt=" << m_ConstVarInt << endl;
  29. std::cout << "m_ConstString=" << m_ConstString << endl;
  30. std::cout << "mStaticConstVarInt=" << mStaticConstVarInt << endl;
  31. }
  33. void printConstVarInt()
  34. {
  35. std::cout << "printConstVarInt !!!!!" << endl;
  36. std::cout << "m_ConstVarInt=" << m_ConstVarInt << endl;
  37. }
  40. private:
  41. const int m_ConstVarInt = 100; // 成员只有 const, 特殊情况C 11特性, non-static data member initializers only available with -std=c 11 or -std=gnu 11
  42. const std::string m_ConstString; // 成员只有 const
  43. static const int mStaticConstVarInt; // 成员既有 const 又有 static
  44. };
  46. const int MyTest::mStaticConstVarInt = 1000;
  49. int main()
  50. {
  52. const MyTest testConst;
  54. // 可以访问
  55. testConst.printMyTest();
  57. // 不可以访问, 会报错
  58. // testConst.printConstVarInt();
  61. return 0;
  62. }

程序运行结果:


  2. printMyTest const !!!!!
  3. m_ConstVarInt=100
  4. m_ConstString=My Test !!!
  5. mStaticConstVarInt=1000

4 const 函数改变成员变量

可以使用 mutable 在const 函数的内部改变成员变量


  2. #include <iostream>
  3. #include <stdio.h>
  4. using namespace std;
  6. class MyTest
  7. {
  8. public:
  10. MyTest():
  11. m_ConstString("My Test !!!")
  12. {
  15. }
  17. void printMyTest()
  18. {
  19. std::cout << "printMyTest !!!!!" << endl;
  20. std::cout << "m_ConstVarInt=" << m_ConstVarInt << endl;
  21. std::cout << "m_ConstString=" << m_ConstString << endl;
  22. std::cout << "mStaticConstVarInt=" << mStaticConstVarInt << endl;
  23. }
  25. void printMyTest() const
  26. {
  27. std::cout << "printMyTest const !!!!!" << endl;
  29. // 成员变量递增
  30. m_VarInt ;
  31. std::cout << "m_VarInt=" << m_VarInt << endl;
  33. std::cout << "m_ConstVarInt=" << m_ConstVarInt << endl;
  34. std::cout << "m_ConstString=" << m_ConstString << endl;
  35. std::cout << "mStaticConstVarInt=" << mStaticConstVarInt << endl;
  36. }
  40. private:
  41. const int m_ConstVarInt = 100; // 成员只有 const, 特殊情况C 11特性, non-static data member initializers only available with -std=c 11 or -std=gnu 11
  42. const std::string m_ConstString; // 成员只有 const
  43. static const int mStaticConstVarInt; // 成员既有 const 又有 static
  44. mutable int m_VarInt; // 普通成员, mutable 可以在const成员函数里面改变值
  45. };
  47. const int MyTest::mStaticConstVarInt = 1000;
  50. int main()
  51. {
  53. const MyTest testConst;
  55. // 第一次调用
  56. testConst.printMyTest();
  58. // 第二次调用
  59. testConst.printMyTest();
  62. return 0;
  63. }

程序运行结果:


  2. printMyTest const !!!!!
  3. m_varInt=1
  4. m_ConstVarInt=100
  5. m_ConstString=My Test !!!
  6. mStaticConstVarInt=1000
  7. printMyTest const !!!!!
  8. m_varInt=2
  9. m_ConstVarInt=100
  10. m_ConstString=My Test !!!
  11. mStaticConstVarInt=1000

5 const 返回值

为什么有的函数的返回值为const?

对返回值使用const有可能提高一个函数的安全性和效率，否则还会出问题。

例如：

const rational operator*(const rational& lhs,

const rational& rhs);

很多程序员第一眼看到它会纳闷：为什么operator*的返回结果是一个const对象？因为如果不是这样，用户就可以做下面这样的坏事：

rational a, b, c;

...

(a * b) = c; // 对a*b的结果赋值

我不知道为什么有些程序员会想到对两个数的运算结果直接赋值，但我却知道：如果a，b和c是固定类型，这样做显然是不合法的。一个好的用户自定义类型的特征是，它会避免那种没道理的与固定类型不兼容的行为。对我来说，对两个数的运算结果赋值是非常没道理的。声明operator*的返回值为const可以防止这种情况，所以这样做才是正确的。

(a) 案例1：非const 返回值, 导致的异常操作

(testOne testTwo) = testThree


  2. #include <iostream>
  3. #include <stdio.h>
  4. using namespace std;
  6. class Test
  7. {
  8. public:
  10. Test(const int varInt = 100):
  11. m_VarInt(varInt)
  12. {
  14. }
  16. // 返回值没有 const
  17. Test operator (const Test& test)
  18. {
  19. Test tmpTest;
  21. tmpTest.m_VarInt = this->m_VarInt test.getVarInt();
  23. return tmpTest;
  24. }
  26. int getVarInt()const
  27. {
  29. return m_VarInt;
  30. }
  32. private:
  34. int m_VarInt;
  36. };
  39. int main()
  40. {
  41. Test testOne(100);
  42. Test testTwo(200);
  44. Test testThree(0);
  46. //这种异常情况, 竟然可以赋值没有编译和运行报错提示
  47. (testOne testTwo) = testThree;
  49. return 0;
  51. }

(a) 案例2：const 返回值, 编译报错处理, 可以保证下述异常不会发生

(testOne testTwo) = testThree


  2. #include <iostream>
  3. #include <stdio.h>
  4. using namespace std;
  6. class Test
  7. {
  8. public:
  10. Test(const int varInt = 100):
  11. m_VarInt(varInt)
  12. {
  14. }
  16. // 返回值加上 const
  17. const Test operator (const Test& test)
  18. {
  19. Test tmpTest;
  21. tmpTest.m_VarInt = this->m_VarInt test.getVarInt();
  23. return tmpTest;
  24. }
  26. int getVarInt()const
  27. {
  29. return m_VarInt;
  30. }
  32. private:
  34. int m_VarInt;
  36. };
  39. int main()
  40. {
  41. Test testOne(100);
  42. Test testTwo(200);
  44. Test testThree(0);
  46. //这种异常情况, 编译编译不能通过, 会报错处理
  47. (testOne testTwo) = testThree;
  49. return 0;
  51. }

6 const 参数

C 引用------( 临时变量、引用参数和const引用 )

如果实参与引用参数不匹配，C 将生成临时变量。如果引用参数是const,则编译器在下面两种情况下生成临时变量：

实参类型是正确的，但不是左值

实参类型不正确，但可以转换为正确的类型

左值参数是可被引用的数据对象，例如，变量、数组元素、结构成员、引用和被解除引用的指针都是左值，非左值包括字面常量和包含多项式的表达式。定义一个函数


  2. double refcube(const double& ra)
  4. {
  6. return ra*ra*ra;
  8. }
  12. double side = 3.0;
  14. double* pd = &side;
  16. double& rd = side;
  18. long edge = 5L;
  20. double lens[4]={2.3,3.4,4.5,6.7};
  22. double c1 = refcube(side); // ra 是side
  24. double c2 = refcube(lens[2]); // ra是lens[2]
  26. double c3 = refcube(rd); // ra 是 rd
  28. double c4 = refcube(*pd); // ra 是*pd
  30. double c5 = refcube(edge); // ra 是临时变量
  32. double c6 = refcube(7.0); // ra 是临时变量
  34. double c7 = refcube(side 10.0); // ra 是临时变量

参数side lens[2] rd 和*pd都是有名称的、double类型的数据对象，因此可以为其创建引用，而不需要临时变量。但是edge虽然是变量，类型却不正确，double引用不能指向long。另一方面，参数7.0和side 10.0的类型都正确，但没有名称，在这些情况下，编译器都将生成一个临时匿名变量，并让ra指向它。这些临时变量只在函数调用期间存在，伺候编译器便可以任意将其删除

那么为什么对于常量引用，这种行为是可行的，其他情况下却不行呢？


  2. void swapr(int& a,int& b)
  4. {
  6. int temp;
  8. temp=a;
  10. a = b;
  12. b = temp;
  14. }

在早期的C 较宽松的规则下，执行下面的操作将发生什么？

long a = 3,b = 5;

swapr(a,b);

这里的类型不匹配，因此编译器将创建两个临时的int变量，将他们初始化为3和5,然后交换临时变量的内容，而a和b保持不变

简而言之，如果接受引用参数的函数的意图是修改作为参数传递的变量，则创建临时变量将阻止这种意图的实现，解决方法是，禁止创建临时变量，现在的C 标准正是这样做的、

现在来看refcube()函数，该函数的目的只是使用传递的值，而不是修改他们，因此临时变量不会造成任何不利的影响。反而会使函数在可处理的参数种类方面更通用。因此，如果声明将引用指定为const，C 将在必要时生成临时变量、实际上，对于形参为const引用的C 函数，如果实参不匹配，则其行为类似于按值传递，为确保原始数据不被修改，将使用临时变量来存储值、

（PS:如果函数调用的参数不是左值或与相应的const引用参数的类型不匹配，则C 将创建类型正确的匿名变量，将函数调用的参数的值传递给该匿名变量，并让参数来引用该变量）

应尽可能使用const

使用cosnt可以避免无意中修改数据的编程错误

使用const使函数能够处理const和非const实参，否则将只能接受非const数据

使用const引用使函数能够正确生成并使用临时变量

电脑交换式登录初始化进程失败,交互式登录初始化失败怎么解决(1)

栏目热文

文档排行

本站推荐

Copyright © 2018 - 2021 www.yd166.com., All Rights Reserved.