C++学习笔记2022.3.22

最新推荐文章于 2024-07-01 20:03:11 发布
最新推荐文章于 2024-07-01 20:03:11 发布
阅读量1.1k 收藏
点赞数
分类专栏： C++学习笔记 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/just_a_fresh_man/article/details/123667535
版权

2022.3.22

类成员,类的组合,友元

  1. 常对象只能调用它的常成员函数,而不能调用普通的成员

    #include<iostream>   //例3.40-2
using namespace std;
class Sample{
 private:
  int n;
 public:
  int m;
   Sample(int i,int j){ m=i; n=j; } 
   void setvalue(int i){ n=i; }
   void disply()
  {cout<<"m="<<m<<endl; 
   cout<<"n="<<n<<endl; } };
int main()
{const Sample a(10,20);
   a.setvalue(40);           
   a.m=30;
   a.disply();  return 0;}

    所以setvalue()方法不能使用

    同时,常对象即便是public数据成员也不能直接修改,

  2. 常函数的说明格式:

    类型说明符 函数名(参数表)const;

    声明带const , 使用不需要,同时,常成员函数不能更新对象的数据成员的值

    #include<iostream>   //例3.40-2
using namespace std;
class Sample{
 private:
  int n;
 public:
  int m;
   Sample(int i,int j){ m=i; n=j; }
   void setvalue(int i){ n=i; }
   void disply() const
  {cout<<"m="<<m<<endl;
   cout<<"n="<<n<<endl; } };
int main()
{const Sample a(10,20);
   a.disply();  return 0;}

    #include<iostream>   //例3.40-2
using namespace std;
class Sample{
 private:
  int n;
 public:
  int m;
   Sample(int i,int j){ m=i; n=j; }
   //void setvalue(int i){ n=i; }
   void disply() ;
   void disply() const ;
};
void Sample::disply()  {
    cout<<"another";
}
void Sample::disply() const
{cout<<"m="<<m<<endl;
    cout<<"n="<<n<<endl; }
int main()
{const Sample a(10,20);
   a.disply();
   Sample b (20,30);
   b.disply();
   return 0;}

    注意下,class最后花括号后面要加个分号

  3. 使用const说明的数据成员称为常数据成员。
    如果在一个类中说明了常数据成员,那么构造函数就只能通过初始化列表对该数据成员进行初始化, 而不能采用在函数中直接赋值的方法

    #include<iostream>   //例3.40-2
using namespace std;
class Sample{
 private:
  const int n,a,b;
 public:
  const int m;
   //void setvalue(int i){ n=i; }
   Sample(int n,int a,int b,int m);
   void disply() ;
   void disply() const ;
};
Sample::Sample(int n, int a, int b, int m):n(n),a(a),b(b),m(m)
{}
void Sample::disply()  {
    cout<<"another";
}
void Sample::disply() const
{cout<<"m="<<m<<endl;
    cout<<"n="<<n<<endl; }
int main()
{const Sample a(10,20,30,40);
   a.disply();
   Sample b (10,90,20,30);
   b.disply();
   return 0;}

    才发现,c++参数列表貌似就是java中this.a=a这个操作,像下面三种,第一种完全达到目的,第二种第三种都得到垃圾值

    #include<iostream>   //例3.40-2
using namespace std;
class Sample{
 private:
  const int n,a,b;
 public:
  const int m;
   //void setvalue(int i){ n=i; }
   Sample(int n,int a,int b,int m);
   void disply() ;
   void disply() const ;
};
Sample::Sample(int n, int a, int b, int m):n(n),a(a),b(b),m(m)
{}
void Sample::disply()  {
    cout<<"another";
}
void Sample::disply() const
{cout<<"m="<<m<<endl;
    cout<<"n="<<n<<endl; }
int main()
{const Sample a(10,20,30,40);
   a.disply();
   Sample b (10,90,20,30);
   b.disply();
   return 0;}

    #include<iostream>   //例3.40-2
using namespace std;
class Sample{
private:
     const int n,a,b;
public:
     const int m;
    //void setvalue(int i){ n=i; }
    Sample(int n,int a,int b,int m);
    void disply() ;
    void disply() const ;
};
Sample::Sample(int n, int a, int b, int m)
{
    n=n;
    m=m;
    a=a;
    b=b;
}
void Sample::disply()  {
    cout<<"another";
}
void Sample::disply() const
{cout<<"m="<<m<<endl;
    cout<<"n="<<n<<endl; }
int main()
{const Sample a(10,20,30,40);
    a.disply();
    Sample b (10,90,20,30);
    b.disply();
    return 0;}

    #include<iostream>   //例3.40-2
using namespace std;
class Sample{
 private:
    int n,a,b;
 public:
  int m;
   //void setvalue(int i){ n=i; }
   Sample(int n,int a,int b,int m);
   void disply() ;
   void disply() const ;
};
Sample::Sample(int n, int a, int b, int m)
{
    n=n;
    m=m;
}
void Sample::disply()  {
    cout<<"another";
}
void Sample::disply() const
{cout<<"m="<<m<<endl;
    cout<<"n="<<n<<endl; }
int main()
{const Sample a(10,20,30,40);
   a.disply();
   Sample b (10,90,20,30);
   b.disply();
   return 0;}

  4. 总结一下,

    普通成员函数常成员函数
    普通数据成员可以访问，也可以改变值可以访问，但不可以改变值
    常数据成员可以访问，但不可以改变值可以访问，但不可以改变值
    常对象的数据成员不允许访问和改变值可以访问，但不可以改变值

  5. 定义静态数据成员的格式如下:

         static 数据类型 数据成员名;

    #include<iostream>   //例3.40-2
using namespace std;
class Sample{
    static int c;
private:
    int n,a,b;
public:
    int m;
    //void setvalue(int i){ n=i; }
    Sample(int n,int a,int b,int m);
    void disply() ;
    void disply() const ;
};
int Sample:: c =79898;
Sample::Sample(int n, int a, int b, int m):n(n),a(a),b(b),m(m)
{}
void Sample::disply()  {
    cout<<"another";
}
void Sample::disply() const
{cout<<"m="<<m<<endl;
    cout<<"n="<<n<<endl;
    cout<<"c="<<c<<endl;
}
int main()
{const Sample a(10,20,30,40);
    a.disply();
    Sample b (10,90,20,30);
    b.disply();
    return 0;}

  6. 静态数据成员的初始化要在main()函数之前,类定义之外

  7. 值得注意,下面这种写法没什么问题(我个人觉得挺离谱的),因为对象的声明的

    #include<iostream>   //例3.40-2
using namespace std;
class Sample{
private:
    int n,a,b;
public:
    static int c;
    int m;
    //void setvalue(int i){ n=i; }
    Sample(int n,int a,int b,int m);
    void disply() ;
    void disply() const ;
};
Sample::Sample(int n, int a, int b, int m):n(n),a(a),b(b),m(m)
{}
void Sample::disply()  {
    cout<<"another";
}
void Sample::disply() const
{cout<<"m="<<m<<endl;
    cout<<"n="<<n<<endl;
    cout<<"c="<<c<<endl;
}
int Sample:: c =79898;
const Sample a(10,20,30,40);
int main()
{
    cout<<Sample::c;
    a.disply();
    Sample b (10,90,20,30);
    b.disply();
    return 0;
}

    #include<iostream>   //例3.40-2
using namespace std;
class Sample{
private:
    int n,a,b;
public:
    static int c;
    int m;
    //void setvalue(int i){ n=i; }
    Sample(int n,int a,int b,int m);
    void disply() ;
    void disply() const ;
};
Sample::Sample(int n, int a, int b, int m):n(n),a(a),b(b),m(m)
{}
void Sample::disply()  {
    cout<<"another";
}
void Sample::disply() const
{cout<<"m="<<m<<endl;
    cout<<"n="<<n<<endl;
    cout<<"c="<<c<<endl;
}
int Sample:: c =7000000;
const Sample a(10,20,30,40);
int main()
{
    Sample:: c =79898;
    cout<<Sample::c;
    a.disply();
    Sample b (10,90,20,30);
    b.disply();
    return 0;
}

    我稍微修改了下,静态数据成员能这么写估计是因为public了,所以声明对象以后又将c的值修改了下,不过这种延后感觉有点不太协调.

  8. 若静态成员函数需要访问非静态成员，静态成员函数只能通过对象名(对象指针或引用)访问该对象的非静态成员

    这个其实挺好理解的,因为静态成员函数在对象声明前存在,所以必须得有引用或者指针或者对象才可以调用函数.(注意下,对象我指的是直接在函数里初始化得到的一个,而指针引用我指的其实是在形参列表处的)

  9. 如何给组合类中的对象成员初始化

    class  X {
   类名1  对象成员名1；
   类名2  对象成员名2；
           …
   类名n  对象成员名n；
 }；

      X∷X(参数表0)：对象成员名1(参数表1)，对象成员名2
       (参数表2)，…，对象成员名n(参数表n) 
  {
     类X的构造函数体
  }

    表现形式

     class A {  //.. ..   };
 class B {  //.. ..   }; 
 class C {  //.. ..   }; 
 class D {
    A  a;     
    B  b;
    C  c;
   public:
    D(参数表0):a(参数表1),b(参数表2),c(参数表3)
    {    // …构造函数体 }
 } ；

  10. 如何用友元函数

    #include<iostream>   //例3.40-2
using namespace std;
class Sample{
private:
    int n,a,b;
public:
    static int c;
    int m;
    //void setvalue(int i){ n=i; }
    Sample(int n,int a,int b,int m);
    void disply() ;
    void disply() const ;
    friend void fun(Sample &w);
};
Sample::Sample(int n, int a, int b, int m):n(n),a(a),b(b),m(m)
{}
void fun(Sample & w){
    cout<<w.c;
}

void Sample::disply()  {
    cout<<"another";
}
void Sample::disply() const
{cout<<"m="<<m<<endl;
    cout<<"n="<<n<<endl;
    cout<<"c="<<c<<endl;
}
int Sample:: c =79898;
int main()
{
    Sample b (10,90,20,30);
    fun(b);
    return 0;
}

    注意下,友元函数不能用const变成常成员函数,也就是友元函数不能处理常对象

    友元函数最大的特点就是,不需要对象或者类的格式就可以直接使用,比较像c语言,至于破坏封装,我其实我现在还没感觉到

    一个函数可以是多个类的友元函数。当一个函数需要访问多个类时，友元函数非常有用,不过这样会非常混乱,改bug可以玩死你,修改个数据也会死的挺惨的

  11. 将其它类成员函数声明为本类友元函数
    一个类的成员函数也可以作为另一个类的友元，这种成员函数称为友元成员函数。
    定义友元成员函数目的：使两个或多个类相互合作、协调工作,完成某一任务。

    成员函数可以访问自己类的对象,不需要引用,然后访问别的类的对象时,则需要

  12. 友元类的说明方法是在另一个类声明中加入语句:

    friend  类名;

     class  Y {
      …
    }；
    class X {
      …
      friend  Y；
      …
    }；

    友元类的一个特点就是Y中的所有函数对于X都是友元函数

  13. string类的直接复制是深拷贝,复制的字符串修改并不影响前面被拷贝的字符串

    #include <string>
#include <iostream>
using namespace  std;
int main(){
    std::string a ="abcd";
    std::string b =a;
    cout<<&a<<endl;
    cout<<&b<<endl;
    std::cout<<a<<std::endl;
    cout<<b<<endl;
    b[0]='h';
    cout<<&a<<endl;
    cout<<&b<<endl;
    cout<<a<<endl;
    cout<<b<<endl;
}

  14. 一段有意思的代码

    #include <string>
#include <iostream>
using namespace  std;
class A {
private:
    int a;
public:
    A(int a);
    void display();
};
A::A(int a) :a(a){
    cout<<"first"<<endl;
}

void A::display() {
    cout<<a;
}
int main(){
    A a =10;
    A b = a;
    a.display();
    b.display();
    return 0;
}
cjz-lxg
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
2022年VBnet学习笔记六VBnet的对象.docx
06-16
3. 使用一种语句实例化，更能表白类型与创立，在接口/继承上更好用：`Dim c As theClass = New theClass()` 4. 在参数中创立实例：`doSomeThing(New theClass())` 5. 在参数中创立实例，同步调用其措施：`...
Java面向对象编程-第7章学习笔记
老梧桐
11-15 915
Java面向对象编程-第7章学习笔记
【精品】[C++入门到精通视频]学习笔记.pdf
09-30
3. **头文件（Header Files, .h）与源文件（Source Files, .cpp）**： - 类的声明通常放在头文件中，供其他源文件包含使用，以达到代码复用。而函数的定义和类的成员函数实现则放在源文件中。这样可以遵循“分离...
2022 CSP-J1 CSP-S1 初赛 资料集（2022.07.08).pdf
07-08
本资源是关于 2022 年 CSP-J1 CSP-S1 初赛的资料集，包含了报名通知、成绩及分数线汇总、相关书籍、培训计划、学习要点、复习方法、知识汇总、模拟题、答案解析、视频等内容。本资源主要面向青少年趣味编程和 C++ ...
专题资料（2021-2022年）Java预习阶段学习笔记.docx
07-19
3. **纯面向对象**：Java强制所有程序都基于面向对象的编程模型，提供了封装、继承和多态等面向对象特性。 4. **开放性**：Java是开源的，拥有丰富的类库和强大的社区支持。 Java的运行机制分为两个主要步骤： 1. ...
【C++】————string基础用法及部分函数底层实现
bhbcdxb123的博客
06-30 846
本文主要介绍STL容器之一 ---- string，在学习C++的过程中，我们要将C++视为一个语言联邦（摘录于Effective C++ 条款一）。如何理解这句话呢，我们学习C++，可将其分为四个板块；分别为C、Object-Oriented C++（面向对象的C++）、Template C++（模板）、STL。本文就介绍STL中的string；1.一个冷知识：屏蔽力是一个人最顶级的能力，任何消耗你的人和事，多看一眼都是你的不对。2.你不用变得很外向，内向挺好的，但需要你发言的时候，一定要勇敢。
《C++ Primer Plus第五版》
风中的默默
06-26 905
连续分段空间,由一段一段的连续空间构成的，用一小块连续的内存空间map作为主控(不是STL的map容器)，里面的每一个元素都是一个指针，指向另一段连续性内存空间，称作缓冲区，默认使用 512 字节大小。假设我们定义一个双向链表，把链表上节点都定义成shared_ptr智能指针，当其中两个节点互相引用的时候，就会出现循环引用的现象。堆是我们通过new关键字来动态申请的内存空间，堆上分配的内存需要我们手动管理，堆是不连续的内存区域，以链表的形式分配的，如果我们没有正确释放堆上的内存可能会出现内存泄漏。
C++精解【7】
应用数学
06-27 1043
使用一种存储顺序的矩阵和数组可以分配给使用另一种存储顺序的矩阵和数组，就像上面的程序中使用Acolmajor初始化Arowmajor时发生的那样。3.缺省情况下，Eigen是列为主的。这意味着，尽管我们的目标是透明地支持列为主和行为主的存储顺序，但Eigen库可能最适合列为主的矩阵。2.当矩阵以行为主的顺序存储时，由于更好的数据局部性，逐行遍历矩阵的算法将运行得更快。为了找出适合您的特定应用程序的更快的方法，进行一些实验可能是值得的。或者，您可以使用Eigen以外的其他库，这些库可能需要特定的存储顺序。
c++函数（三）习题讲解
m0_62681656的博客
07-01 319
ave 函数传递了两个数据类型的参数，一个是 int 类型，一个是 float 类型，在进行运算的时候会发生类型转换，而 float 类型的优先级要大于 int 类型，所以返回的是 float 类型，那为什么不是引用类型呢？解析：这道题考察预处理指令，#define _H_ 定义了一个 宏，#ifdef _H_判断宏存在，之后 执行 a++ ，之后又执行 a++ ，结果 a = 102，选C。解析：这道题考查的是 当模板函数和 重载函数同时存在时，他俩的优先级的高低，更快，但同样不支持可变数量的参数。
什么野指针（c++）
qq_35374791的博客
06-24 8841
野指针（Wild Pointer）是指向不确定位置或者非法地址的指针。当一个指针指向的内存被释放后，如果没有将其设置为NULL，那么这个指针就变成了野指针。使用野指针会导致未定义行为，可能引发程序崩溃或数据损坏。
区间动态规划——最长回文子序列长度（C++）
m0_73962294的博客
07-01 503
把夜熬成粥，然后喝了它。
C语言从头学28——数组（一）
最新发布
m0_72128260的博客
07-01 427
数组是一组相同类型的值被顺序地储存在一起。数组表示方法为变量名加方括号，方括号里是数组的成员数量。
CPPTest设计分析
flysnow010的博客
06-27 862
CppTest是一个可移植、功能强大但简单的单元测试框架，用于处理C++中的自动化测试。重点在于可用性和可扩展性。支持多种输出格式，并且可以轻松添加新的输出格式。CppTest下载地址Github地址下面对其设计进行分析，已更好对其使用。
c++中popen执行linux命令失败，如何打印出错原因？
2401_84909878的博客
06-26 207
关闭文件指针之前，你应该确保已经读取了所有的输出（或者至少已经读取了足够的输出以防止缓冲区溢出）。否则，你可能会丢失一些输出或遇到其他问题。函数执行Linux命令失败，并且想要打印出失败的原因，你可以通过检查。是一个全局变量，它会在系统调用或库函数出错时被设置。函数会将这个错误码转换为一个可读的字符串。函数来获取并打印出具体的错误原因。下面是一个示例代码，展示了如何使用。替换为你想要执行的命令）。来获取并打印出具体的错误原因。在上面的代码中，我们尝试使用。在C++中，如果你使用。执行一个命令（你需要将。
C++ 教程 - 08 文件操作与异常处理
weixin_45228198的博客
07-01 210
c++; 文件处理；异常处理
383. 赎金信【哈希表】【C++】
xaiobai123的博客
06-26 201
然后遍历magazine 数组，在哈希表上减，如果出现了负数则为返回false。给你两个字符串：ransomNote 和 magazine ，判断 ransomNote 能不能由 magazine 里面的字符构成。输入：ransomNote = “aa”, magazine = “aab”输入：ransomNote = “aa”, magazine = “ab”magazine 中的每个字符只能在 ransomNote 中使用一次。输入：ransomNote = “a”, magazine = “b”
valgrind调试c/c++内存问题:非法地址访问_内存泄漏_越界访问
u011326325的博客
06-27 916
valgrind调试内存非法地址访问, 内存泄漏, 越界访问
【C++之unordered_set和unordered_map的介绍与应用】
m0_69455439的博客
07-01 433
C++学习笔记024 ---unordered_set和unordered_map的介绍与应用等知识
c++跨平台编译宏区分的两种办法
Hunter_pcx的博客
06-28 296
跨平台编译宏的两种方式
idea2022.3.3
03-07
Idea 2022.3.3是JetBrains公司开发的一款集成开发环境（IDE），它主要用于软件开发和编程。Idea提供了丰富的功能和工具，可以支持多种编程语言，包括Java、Python、C++等。它具有智能代码编辑、代码自动补全、代码...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

cjz-lxg

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值