7 篇笔记 写笔记

1. #0

   董老爷

   zeh***[email protected]

   186

   关于C++中this指针的理解:当你进入一个房子后,你可以看到房子内的桌子、椅子、地板等;但是你看不到房子的全貌;对于类来说,你可以看到成员函数、成员变量,但你看不到实例本身,但是应用this可以让我们看到这个实例本身。

   我的理解:class类就好比这座房子,this就好比一把钥匙,通过钥匙来打开了这座房子的门,那么里面的东西就随意你取用了。

   因为this作用域是在类的内部,自己声明一个类的时候,还不知道实例化对象的名字,所以用this来使用对象变量的自身。在非静态成员函数中,编译器在编译的时候加上this作为隐含形参,通过this来访问各个成员(即使你没有写上this指针)

   代码实例:

   class Point
   { 
    int x, y;
    public:
    Point(int a, int b) { x=a; y=b;}
    void MovePoint( int a, int b){ x+=a; y+=b;}
    void print(){ cout<<"x="< }
    void main( )
    {
    Point point1( 10,10);
    point1.MovePoint(2,2);
    point1.print( );
    }
   }
   

   董老爷

   zeh***[email protected]

   9年前 (2017年11月05日)
2. #0

   helloworld

   229***[email protected]

   385

   C++ 中的 struct 对 C 中的 struct 进行了扩充,它已经不再只是一个包含不同数据类型的数据结构了,它已经获取了太多的功能。

   struct 能包含成员函数吗? 能!

   struct 能继承吗? 能!!

   struct 能实现多态吗? 能!!!

   既然这些它都能实现,那它和 class 还能有什么区别?

   最本质的一个区别就是默认的访问控制,体现在两个方面:

   1)默认的继承访问权限。struct是public的,class是private的。

   你可以写如下的代码:

   struct A
   {
    char a;
   };
   struct B : A
   {
    char b;
   };

   这个时候 B 是 public 继承 A 的。

   如果都将上面的 struct 改成 class,那么 B 是 private 继承 A 的。这就是默认的继承访问权限。

   所以我们在平时写类继承的时候,通常会这样写:

   struct B : public A

   就是为了指明是 public 继承,而不是用默认的 private 继承。

   当然,到底默认是 public 继承还是 private 继承,取决于子类而不是基类。

   我的意思是,struct 可以继承 class,同样 class 也可以继承 struct,那么默认的继承访问权限是看子类到底是用的 struct 还是 class。如下:

   struct A{}; 
   class B : A{}; //private继承
   struct C : B{}; //public继承

   2)struct 作为数据结构的实现体,它默认的数据访问控制是 public 的,而 class 作为对象的实现体,它默认的成员变量访问控制是 private 的。

   注意我上面的用词,我依旧强调 struct 是一种数据结构的实现体,虽然它是可以像 class 一样的用。我依旧将 struct 里的变量叫数据,class 内的变量叫成员,虽然它们并无区别。

   其实,到底是用 struct 还是 class,完全看个人的喜好,你可以将你程序里所有的 class 全部替换成 struct,它依旧可以很正常的运行。但我给出的最好建议,还是:当你觉得你要做的更像是一种数据结构的话,那么用 struct,如果你要做的更像是一种对象的话,那么用 class。

   当然,我在这里还要强调一点的就是,对于访问控制,应该在程序里明确的指出,而不是依靠默认,这是一个良好的习惯,也让你的代码更具可读性。

   说到这里,很多了解的人或许都认为这个话题可以结束了,因为他们知道 struct 和 class 的"唯一"区别就是访问控制。很多文献上也确实只提到这一个区别。

   但我上面却没有用"唯一",而是说的"最本质",那是因为,它们确实还有另一个区别,虽然那个区别我们平时可能很少涉及。那就是:"class" 这个关键字还用于定义模板参数,就像 "typename"。但关键字 "struct" 不用于定义模板参数。这一点在 Stanley B.Lippman 写的 Inside the C++ Object Model 有过说明。

   问题讨论到这里,基本上应该可以结束了。但有人曾说过,他还发现过其他的"区别",那么,让我们来看看,这到底是不是又一个区别。还是上面所说的,C++ 中的 struct 是对 C 中的 struct 的扩充,既然是扩充,那么它就要兼容过去 C 中 struct 应有的所有特性。例如你可以这样写:

   struct A //定义一个struct
   {
    char c1;
    int n2;
    double db3;
   };
   A a={'p',7,3.1415926}; //定义时直接赋值

   也就是说 struct 可以在定义的时候用 {} 赋初值。那么问题来了,class 行不行呢?将上面的 struct 改成 class,试试看。报错!噢~于是那人跳出来说,他又找到了一个区别。我们仔细看看,这真的又是一个区别吗?

   你试着向上面的 struct 中加入一个构造函数(或虚函数),你会发现什么?

   对,struct 也不能用 {} 赋初值了。

   的确,以 {} 的方式来赋初值,只是用一个初始化列表来对数据进行按顺序的初始化,如上面如果写成 A a={'p',7}; 则 c1,n2 被初始化,而 db3 没有。这样简单的 copy 操作,只能发生在简单的数据结构上,而不应该放在对象上。加入一个构造函数或是一个虚函数会使 struct 更体现出一种对象的特性,而使此{}操作不再有效。

   事实上,是因为加入这样的函数,使得类的内部结构发生了变化。而加入一个普通的成员函数呢?你会发现{}依旧可用。其实你可以将普通的函数理解成对数据结构的一种算法,这并不打破它数据结构的特性。

   那么,看到这里,我们发现即使是 struct 想用 {} 来赋初值,它也必须满足很多的约束条件,这些条件实际上就是让 struct 更体现出一种数据机构而不是类的特性。

   那为什么我们在上面仅仅将 struct 改成 class,{} 就不能用了呢?

   其实问题恰巧是我们之前所讲的——访问控制!你看看,我们忘记了什么?对,将 struct 改成 class 的时候,访问控制由 public 变为 private 了,那当然就不能用 {} 来赋初值了。加上一个 public,你会发现,class 也是能用 {} 的,和 struct 毫无区别!!!

   做个总结,从上面的区别,我们可以看出,struct 更适合看成是一个数据结构的实现体,class 更适合看成是一个对象的实现体。

   helloworld

   229***[email protected]

   9年前 (2018年01月16日)
3. #0

   张家子谦

   492***[email protected]

   54

   在类的外面,其实也可以用指针访问类内部的私有成员,例如:

   #include <iostream>
   using namespace std;
   class a // 定义了类a
   {
    long a0; // 定义私有成员 a0
    public:
    a(long b)
    {
    a0=b;
    }
    void geta()
    {
    cout<<a0<<endl;
    }
   };
   int main()
   {
    a b(5); // 定义对象b,并给 b 中的 a0 赋初值
    long *p;
    p=(long*)&b; // 令指针 p 指向 b 中前 4 个字节,在这里相当于指向 a0
    b.geta(); // 用内部函数访问 a0
    cout<<*p<<endl; // 在外部直接访问 a0
    *p=8; // 在外部改变 a0 的值
    b.geta(); // 输出改变后的结果
    cout<<*p<<endl;
    return 0;
   }

   需要注意的是,使用这种方法虽然可以用于基于类的多态原则的一些程序开发,但违反了类的封装原则,在使用指针的类中也极不安全,所以不建议使用。

   张家子谦

   张家子谦

   492***[email protected]

   8年前 (2018年05月11日)
4. #0

   FS

   429***[email protected]

   621

   FS

   429***[email protected]

   8年前 (2018年11月22日)
5. #0

   csjpli

   ljp***@163.com

   44

   类对象初始化的时候加括号与不加括号有什么区别~

   #include<iostream>
   using namespace std;
    
   class A
   {
   public:
    A()
    {
    cout << "A()" << endl;
    }
    A(int a)
    {
    cout << "A(int a)" << endl;
    }
   };
    
   int main()
   {
    //栈上
    //warning C4930 : “A a(void)” : 未调用原型函数(是否是有意用变量定义的 ? )
    A a();//这里声明了一个函数,没有传入的参数,返回值为类类型
    cout << "~~~~~~~~~~~" << endl;
    A b;//默认调用“对象名()”这个构造函数构造对象
    cout << "~~~~~~~~~~~" << endl;
    A c(1);//默认调用相应的构造函数构造对象
    
    //堆上,加括号不加括号无差别,都调用默认的构造函数
    A *d = new A();
    A *e = new A;
    
    //对于内置类型而言,加括号是进行了初始化,不加是未进行初始化
    int *f = new int();
    int *g = new int;
    
    cout << *f << endl;
    cout << *g << endl;
    system("pause");
    return 0;
   }

   csjpli

   ljp***@163.com

   7年前 (2019年10月16日)
6. #0

   修罗逮C

   dua***[email protected]

   11

   当把一个对象赋值给另一个对象时发生了什么?

   Box Box1; // 创建 Box1,执行后Box1已存在
   Box Box2; // 创建 Box2,执行后Box2已存在
   Box2 = Box1; // 这时是把Box1的成员变量值复制给了Box2,Box2还是原来的对象,并没有被销毁,对象地址还是原来的 地址。
   Box &Box3 = Box1; // 创建Box1的引用变量Box3. 

   其中 Box &Box3 = Box1,类似 Java 中 Box3 = Box1。

   和 Java 中的区别:C++中的引用必须在创建时初始化,且创建后不能再指向别的对象,而 Java 中一个对象名可以随时指向另一个同类对象。

   用如下示例得出的以上论断:

   #include <iostream>
    
   using namespace std;
    
   class Box
   {
    public:
    double length; // 长度
    double breadth; // 宽度
    double height; // 高度
    // 成员函数声明
    double get(void);
    void set( double len, double bre, double hei );
   };
   // 成员函数定义
   double Box::get(void)
   {
    return length * breadth * height;
   }
    
   void Box::set( double len, double bre, double hei)
   {
    length = len;
    breadth = bre;
    height = hei;
   }
   int main( )
   {
    Box Box1; // 声明 Box1,类型为 Box
    Box Box2; // 声明 Box2,类型为 Box
    double volume = 0.0; // 用于存储体积
    
    // box 1 详述
    Box1.height = 5.0; 
    Box1.length = 6.0; 
    Box1.breadth = 7.0;
    
    
    // box 1 的体积
    volume = Box1.height * Box1.length * Box1.breadth;
    cout << "Box1 的地址:" << &Box1 <<endl;
    cout << "Box1 的体积:" << volume <<endl;
    
    // box 2 详述
    volume = Box2.get(); 
    cout << "Box2 的地址:" << &Box2 <<endl;
    cout << "Box2 的体积:" << volume <<endl;
    
    Box2 = Box1;
    volume = Box2.get();
    cout << "Box2 的地址:" << &Box2 <<endl;
    cout << "Box2 的体积:" << volume <<endl;
    return 0;
   }

   运行结果:

   Box1 的地址:0x7fff5b11a380
   Box1 的体积:210
   Box2 的地址:0x7fff5b11a360
   Box2 的体积:0
   Box2 的地址:0x7fff5b11a360
   Box2 的体积:210

   要深入理解这点请和拷贝构造函数和对象的引用放在一起对比理解。

   修罗逮C

   dua***[email protected]

   4年前 (2022年09月12日)
7. #0

   侠客不留名

   405***[email protected]

   22

   这样理解比较直观,不然初学者根本理解不了。

   // 1. 基础准备
   #include <iostream> // 引入输入输出库
   using namespace std; // 使用标准命名空间(简化代码书写)
   // 2. 盒子类的声明
   class Box {
   public: // 公有访问权限(初学者先记住这是必要结构)
    // 成员变量(物体的三维属性)
    double length; // 长
    double breadth; // 宽
    double height; // 高
    
    // 成员函数声明(能力说明)
    double get(); // 获取体积
    void set(double l, double b, double h); // 设置尺寸
   };
   // 3. 成员函数具体实现
   double Box::get() { // 双冒号表示属于Box类的函数
    return length * breadth * height; // 体积计算公式
   }
   void Box::set(double l, double b, double h) {
    length = l; // 将参数值赋给成员变量
    breadth = b;
    height = h;
   }
   // 4. 主程序(使用案例)
   int main() {
    // 创建三个不同的盒子对象
    Box Box1, Box2, Box3; 
    double volume = 0; // 临时存储计算结果
    /* 操作方式对比 */
    // 方式一:直接操作成员变量(公开访问)
    Box1.height = 5; // ▢ 直接设置高度
    Box1.length = 6; // ▢ 直接设置长度
    Box1.breadth = 7; // ▢ 直接设置宽度
    volume = Box1.height * Box1.length * Box1.breadth;
    cout << "Box1体积:" << volume << endl; // 输出结果
    // 方式二:通过方法操作(推荐方式)
    Box3.set(16, 8, 12); // 一键设置所有尺寸
    volume = Box3.get(); // 自动计算体积
    cout << "Box3体积:" << volume << endl;
    return 0;
   }

   侠客不留名

   405***[email protected]

   1年前 (2025年04月07日)