C++ 学习笔记（一）

最新推荐文章于 2022-10-20 12:09:37 发布
最新推荐文章于 2022-10-20 12:09:37 发布
阅读量334 收藏
点赞数
分类专栏： C++学习日志 文章标签： 类 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_47152812/article/details/109444134
版权

C++ 学习笔记（一）

vscode按F7编译，
vscode运行图：
在这里插入图片描述

类，构造函数，拷贝函数

#include <iostream>
using nam``espace  std;
class CTime
{
    private:
    int hour,minute,second;
    public:
    void print()
    {
        cout<<hour<<":"<<minute<<":"<<second<<endl;
    }
    CTime(int h,int m,int s)  //带参数的构造函数
    {
        hour=h;
        minute=m;
        second=s;
    }
    CTime(CTime &t)  //拷贝构造函数，参数为同类对象的引用
    {
        hour=t.hour;
        minute=t.minute;
        second=t.second;
    }
};
int main()
{
   CTime t1(8,30,20); //创建对象时以参数的形式为对象初始化
   t1.print();
   CTime t2(t1);
    t2.print();
    return 0;
}

常对象和常对象函数


#include <iostream>
using namespace  std;
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()const  //常成员函数
    {
        cout<<"x="<<x<<"   y="<<y<<endl;
    }
};
int main()
{
   Point point1(1,1);  //Point1为普通对象
   point1.print();
   const Point point2(2,2);  //point2为常对象
   point1.MovePoint(3,3);   //普通成员函数调用一般成员对象，常成员函数不能更新对象数据，
   point2.print();          //也不能调用其他非常的成员函数，但可以被其他成员函数调用
   point1.print();
   return 0;
}

对象的动态建立和释放

~A为析构函数，常用于释放内存单元。
类体外定义函数时，函数名前要加类名和作用域运算符::。


#include <iostream>
#include <string>
using namespace  std;
class A
{
    private:
    string name;
    public:
    A();
    A(string);   //定义函数
    ~A();  //析构函数，与构造函数类似，只在函数名前加～，不带任何参数，也不带返回值（包括void类型）,常用于释放内存单元
};
A：：A  //在类体外定义成员函数时，函数名前要加类名和作用域运算符：：
{
    cout<<"默认构造函数正在执行，创建无名对象"<<endl;
}
A：：A(string s):name(s)
{
    cout<<"带参构造函数A()正在执行，创建对象："<<name<<endl;
}
A：：~A()
{
    cout<<"~A()正在执行，析勾对象："<<name<<endl;
}
int main()
{
   A *pt1 =new A("aaa");  //调用带参数的构造函数，创建对象aaa
   A *pt2 =new A();  //调用默认构造函数，创建无名对象
   delete pt2;   //delete调用析构函数撤销无名对象
   A *ptr =&A();  //调用默认构造函数创建无名对象
                  //该无名对象的撤销是系统自动调用析构函数进行的
   delete pt1;    //delete调用析构函数撤销对象aaa
   return 0;
}

运行结果应为：
带参构造函数A()正在执行，创建对象:aaa
默认构造函数正在执行，创建无名对象
~A()正在执行，析构对象
默认构造函数正在执行，创建无名对象
~A()正在执行，析构对象
~A()正在执行，析构对象aaa

但是一直报错运行不出来，可能vscode不能识别::符号，现将函数的定义移至类内，程序如下：


#include <iostream>
#include <string>
using namespace  std;
class A
{
    private:
    string name;
    public:
    A()
    {
        cout<<"默认构造函数正在执行，创建无名对象"<<endl;
    }
   A(string s):name(s) //定义函数
   {
       cout<<"带参构造函数A()正在执行，创建对象："<<name<<endl;
   }
     ~A()  //析构函数，与构造函数类似，只在函数名前加～，不带任何参数，也不带返回值（包括void类型）,常用于释放内存单元
    {
       cout<<"~A()正在执行，析勾对象："<<name<<endl; 
    }
};
//A::A()  //在类体外定义成员函数时，函数名前要加类名和作用域运算符::
//{
   // cout<<"默认构造函数正在执行，创建无名对象"<<endl;
//}
//A::A (string s):name(s)
///{
    //cout<<"带参构造函数A()正在执行，创建对象："<<name<<endl;
//}
//A::~A()
//{
    //cout<<"~A()正在执行，析勾对象："<<name<<endl;
//}
int main()
{
   A *pt1 =new A("aaa");  //调用带参数的构造函数，创建对象aaa
   A *pt2 =new A();  //调用默认构造函数，创建无名对象
   delete pt2;   //delete调用析构函数撤销无名对象
  // A *ptr =&A(); //调用默认构造函数创建无名对象
                  //该无名对象的撤销是系统自动调用析构函数进行的
   delete pt1;    //delete调用析构函数撤销对象aaa
   return 0;
}

运行结果：
带参构造函数A()正在执行，创建对象：aaa
默认构造函数正在执行，创建无名对象
~A()正在执行，析勾对象：
~A()正在执行，析勾对象：aaa

this指针


#include <iostream>
using namespace std;
class Point
{
    private:  //Point类的两个私有数据成员
    int x,y;
    public:   //构造函数，初始化数据成员
     Point(int a,int b)
     {
         x=a;
         y=b;
     }
    void MovePoint(int a,int b)   //成员函数，计算移动后的新坐标
    {
        this->x+=a;   //this指针指向对象，this->x表示对象的数据成员，
        this->y+=b;   //等价于x+=a
    }
    void print()   //成员函数，输出点的坐标
    {
        cout<<"x="<<x<<",   y="<<y<<endl;
    }
};
int main()
{
    Point point1(10,10);   //创建对象point1并初始化
    point1. MovePoint(2,2);  //通过对象point1调用成员函数MovePoint（）
    point1.print();     //通过对象point1调用成员函数print（）
    return(0);
}

运行结果：
x=12, y=12

友元函数和友元类

有时需要定义一些函数，这些函数不是类的一部分，但又要频繁访问类的数据成员，这时将这些函数定义为该类的友元函数。
友元函数
友元函数是类外的函数，但声明要放在类内的私有段或公有段


#include <iostream>
using namespace std;
class A
{
    private: 
    int x;
    friend int func(A &a,int j);    //声明友元函数func(),友元函数是类外的函数，但声明要放在类内的私有段或公有段
    public:  
    A(int i)      //构造函数
    {
        x=i;
    }
};
int func(A &a,int j)
{
    return a.x+j;   //在func（）中通过类A的对象a调用了类A的私有成员x
}
int main()
{
    A a(3);
    cout<<func(a,6);  //友元函数不属于类，直接调用，不要用a.func()
    return 0;

}

运行结果：9

友元成员函数
要在public段声明，在类外定义


#include <iostream>
using namespace std;
class B;
class A
{
    private: 
    int x;
    public:  
    A()      
    {
        this->x=0;  //等价x=0
    }
    void display(B &v);  //成员函数声明
    
};
class B 
{
    private:
    int y;
    int z;
    public:
    B()   //类B的构造函数声明，无参数
    {
        this->y=0;     //类B的私有成员y，z初始化为0
        this->z=0;
    }
    B(int y,int z)  //类B的构造函数声明，含两个参数
    {
        this->y=y;  //类B的私有成员y，z初始化为为参数值
        this->z=z;  
    }
    friend void A::display(B &);  //类A 的成员函数display（）被声明为类B友元函数
};
void A::display(B &v)     //友元函数display（）定义
{
    cout<<"v.y="<<v.y<<endl;
        cout<<"v.z="<<v.z<<endl;  //友元函数内可以通过类B的对象访问B的私有成员y，z
        x=v.y+v.z;               //x等价于this->x
        cout<<"x="<<x<<endl;
}
        
     
int main()
{
    A a;
    B b(2,3);
    a.display(b);
    return 0;

}

运行结果：
v.y=2
v.z=3
x=5

友元类


#include <iostream>
using namespace std;
class B;
class A
{
    private: 
    int x;
    public:  
    friend class B;   //声明类B是类A的友元类
    void display()   //成员函数声明
    {
        cout<<x<<endl;
    }
};
class B 
{
    private:
    A a;
    public:
    B(int i)   //类B的构造函数声明，无参数
    {
       a.x=i;
    }
    void display()   //成员函数声明
    {
        cout<<"a.x="<<a.x<<endl;  //类B的成员函数可以直接访问类A的私有成员x
    }
    void display1()   //成员函数声明
    {
        cout<<"a.display()=";
        a.display();   //类B的成员函数可以直接访问类A的私有成员x
    }
};
int main()
{
    B b(10);
    b.display();
    b.display1();

}

运行结果：
a.x=10
a.display()=10

类的静态成员和静态成员函数

静态数据成员
数据类型前加关键字static。
当同一类定义了多个对象时，不同对象的静态数据成员实际上是同一变量。可实现数据在各个对象间的共享和消息传递，它的值可以更新。
静态数据成员属于类，它的初始化与一般数据成员初始化不一样，不是通过构造函数进行。要在类体外初始化，但要在类内进行声明。

#include <iostream>
using namespace std;
class Myclass
{
    public:
    Myclass(int i,int j,int k)  //构造函数定义
{
    a=i;     
    b=j;
    c=k;
    Sum+=i+j+k;
}

    void  GetSum()   //成员函数GetSum() 定义，用于输出Sum的值
    {
       cout<<"Sum="<<Sum<<endl;
    }
    private:
    int a,b,c;
    static int Sum;  //声明类的的静态数据成员Sum
};
int Myclass::Sum=0;  //定义并初始化静态数据成员
int main()
{
    Myclass M(1,2,3);
    M.GetSum();
    Myclass N(4,5,6); 
    N.GetSum();  //输出静态数据成员Sum的值
    M.GetSum();   //输出静态数据成员Sum的值
}

运行结果：
Sum=6
Sum=21
Sum=21
静态成员函数
函数类型前加关键字static。
静态成员函数属于类而不是具体某个对象。
静态成员函数不能直接访问类的非静态数据成员，也无法直接访问非静态成员函数，只能直接访问静态成员函数和静态数据成员。但它可以通过类的对象间接访问非静态数据成员和非静态成员函数。
如果在类体内只是静态成员函数的声明，在类体外进行函数定义时不能再指定关键字static。

#include <iostream>
#include <string>
using namespace std;
class Student
{
    static int number;  //声明类的的静态数据成员
    string name;
    public:
    void set(string str)  //构造函数定义
{
    name=str;
    number++;  //非静态成员函数调用静态数据成员
}

    void  print()   //非静态成员函数print()调用静态数据成员
    {
       cout<<"1:The number of the studens is" <<number<<"numbers."<<endl;
    }
   static void  print2(Student &s)  //静态成员函数print2()
   {
       cout<<"2:The number of the studens is" <<number<<"numbers."<<endl;
       cout<<s.name<<endl;   //通过对象s调用非静态数据成员
       s.print();            //通过对象s调用非静态成员函数
    }
    
};
int Student::number=0;  //初始化静态数据成员只能在类外，并且数据类型前不加static
int main()
{
    Student s;
    s.set("smith");
    s.print2(s); 
    return(0);
}

运行结果：
2:The number of the studens is1numbers.
smith
1:The number of the studens is1numbers.

心飞扬(●ˇ∀ˇ●)
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++的学习心得和知识总结 第三章（待续）
孤傲小二~阿沐的博客
07-06 799
本章：C++的OOP（面向对象部分） +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 第一节：类和对象、this指针 （1）如何用OOP编程？ 在C中：定义各种各样的函数，struct可以自定义类型 在C++中：输出各种各样的类。类（给用户自定义类型的，描述为实体的抽象类型）在计算机世界里面的类来代表现实世界的实体...
C++第三章总结
Sukiugg的博客
03-24 232
函数： 函数的定义与使用： 函数的参数传递：1.值传递 2.引用传递 内联函数： inline 类型说明符 函数名（含类型说明的形参表） { 语句序列 } 带默认形参值的函数： 函数在定义时可预先声明默认的形参值 有默认值的形参必须在形参列表的最后 在形同的作...
C++ 第三章 类和对象知识点总结（复习）
BAmbition的博客
04-17 569
目录 1.成员 2.对象（成员访问，初始化方式） 3.对象数组和对象指针 4.string类 5.对象作为函数参数 6.拷贝构造函数 7.静态成员 8.友元 9.常类型 1.成员 1.比较特殊的成员类型：protected. 保护成员在本类中和private类型的成员作用一模一样。区别在于保护成员可以由本类的派生类的成员函数访问，但是私有成员在其派生类中...
C++ Primer 知识点总结 （第三章）
asdd_1的博客
11-13 248
命名空间 头文件：可将类、全局变量等在头文件中声明，为了防止头文件的重复包含，通常应该使用预处理指令 #define （定义符号）、#ifndef（如果没有定义）、#endif（结束判断）来书写头文件的内容。 字符串、向量和数组 getline(cin , stringname) ：从输入流中读入内容直到读入换行符，保留空白符，但换行符不存入string对象中 字面值与string：字符字面值和字符
C++学习笔记本
05-14
C++学习笔记C++学习笔记C++学习笔记C++学习笔记C++学习笔记
C++学习笔记.pdf
08-12
C++学习笔记
c++学习笔记.pdf
07-12
c++学习笔记.pdf
C++学习笔记
04-01
C++是C语言的继承，它既可以进行C语言的过程化程序设计，又可以进行以抽象数据类型为特点的基于对象的程序设计，还可以进行以继承和多态为特点的面向对象的程序设计。
C++Primer第三章知识总结
qq_47466050的博客
06-09 130
C++Primer第三章知识总结 1、string和数组的比较 （1）string和数组的定义和类型 ①string类型是可变长的字符序列，是C++标准库类型（是由C++标准库提供的一种程序员定义的类型）。 ②数组是相同类型对象的容器，是内置的复合类型（内置类型：是语言本身定义的类型），不是程序员定义的类类型。 （2）string和数组对begin和end函数的使用 ①string类里有很多成员函数，其中包括begin和end函数；string对象可以通过点运算符来使用这些函数，假设一个string对象为s
第三章 C++总结之程序设计初步
gabby____的博客
01-05 442
一、算法的概念 （二）算法的表示 1、自然语言 2、流程图 3、伪代码 4、用计算机语言表示算法 二、C++的程序结构和C++语句 1、每一个程序单位由以下3个部分组成: （1）预处理指令 如#include指令和#define指令 （2）全局声明 在函数外对数据类型、函数以及变量的声明和定义 （3）函数 包括函数首部和函数体，在函数体中可以包含声明语句和执行语句 2、...
C++程序设计（第3版 谭浩强）重点知识点整理 第三章
m0_59312484的博客
09-08 1160
第三章 程序设计初步 3.1 基于过程的程序设计和算法 3.1.1 算法的概念 对于基于过程的程序，可以用下面的公式表示： 程序 = 算法 + 数据结构 3.1.2 算法的表示 1.自然语言 2.流程图 3.伪代码 4.用计算机语言表示的算法 3.2 C++的程序结构和C++语句 1.一个程序包含一个或多个程序单位（每个程序单位构成一个程序文件）。每一个程序单位由以下3个部分组成： ...
《C++大学教程》 前3章 笔记
战死为止的博客
12-22 475
本来想着不再更这部分的，觉得写的博客越来越没有深度。 但是后来一想，还是觉得敲一遍，哪怕是仅仅是为了加深一下印象。 四到六章已看完，回头更。 来H即将四个月，还是控制不住的迷茫，还是没有定下来自己的Focus。
C++ Primer阅读心得（第三章）
lezardfu的专栏
01-13 1197
1. const_iterator和const iterator：在容器中，存在一个const_iterator的迭代器，对这个跌迭代器使用*号（解引用）将返回一个const对象。也就说使用const_iterator只能只读的访问容器中的数据，但是const_iterator本身可以修改。而const iterator就是普通的const对象，一旦设定就不能改变了。（怎么和const指针与指向c
《面向对象程序设计 C++》指向对象的指针
紫藤&code的博客
12-15 518
成员选择运算符. class C{ public: void m(){ /*...*/ } }; void f( C&amp;amp; ); int main(){ C c1; c1.m(); // object f(c1); } void f( C&amp;amp; c){ c.m(); //object reference } 本例展示了对象c1和对象引用c使用成员选择操作符的语法，成员选择运算符...
【C++】面向对象/this指针的使用
weixin_52958292的博客
10-20 313
如果是内联函数就不需要，传入this，因为会在调用点代码直接展开，根本不需要开辟栈帧，也就不需要this指针去指向开辟各自的私有成员属性的空间。不是类的成员方法，全局函数按照普通函数编译，不会按照类的方法编译，给予this指针。答，没有，对象调用成员方法，是将对象的地址传给成员方法，从而达到每个对象独立的访问私有成员属性。所以，从逻辑上讲，是对象调用方法，从底层讲，其实将当前对象作为地址传递给成员方法。类中的静态成员函数，友元函数，内联函数没有this指针。人的行为：打羽毛球，上班，吃饭，睡觉等。
C++笔记——c++编程思想（上）前3章
zhangren07的专栏
03-17 1483
为了准备找工作，复习了一段时间的c++，而且有些内容当时复习了得还比较细致，做的笔记是纸质的，为了不使自己的这部分资料遗失，把它一点点放到网上来吧，从今天开始，一点一点。C++笔记——C++编程思想第一章 对象导言1. 面向对象三大特性：封装、继承、多态。2. C ++中的多态（晚捆绑）是通过虚函数实现的，在父类函数声明前加上关键字Virtual3. 把处理派生类型就如处理
C++ primer笔记 第三章
Charle_s的博客
10-02 87
b3.1 命名空间using声明 using std::cin 声明后可以直接用cin，不用加std了 注意头文件最好不要用using 3.2 标准库类型 string 如果用等号初始化string，就叫做拷贝初始化 反之叫直接初始化。例如 string s(10, 'S'); 可以读空格的输入 getline（cin， str）； str.size()返回的是unsigned 类型，因此最好不要和int型进行比较和计算 例如： string str = "asfas"; int..
C++第3章 表达式与语句
Catherinemin的博客
08-28 313
3.1运算符 3.1.1 算术运算符——加减乘除+-*/ #include<iostream> using namespace std; int main() { int a1 = 10; int b1 = 3; cout << a1 + b1 << endl; cout << a1 - b1 << endl; cout << a1 * b1 << endl; cout << a1 / b1
零基础c++学习笔记pdf
最新发布
05-16
《零基础C语言学习笔记》pdf是一份非常好的学习材料。该pdf对C语言进行了系统的介绍，并且从最基础的内容开始进行讲解，适合于零基础的初学者学习。尤其是对于那些没有编程经验的人，该pdf提供了很多实用的示例和...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值