c++基础/类和对象

Neo_21

已于 2023-03-03 11:51:55 修改

阅读量804

点赞数 1

分类专栏： C++ 文章标签： c++ c语言

于 2023-03-03 11:45:13 首次发布

本文链接：https://blog.csdn.net/Neo_21/article/details/129283639

版权

C++ 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

c++基础

2.1名字空间

namespace 防止命名冲突

说明：名字空间可以在全局作用域或其他作用域（另一个名字空间）内部定义，但不能在函数或类的内部定义。

使用：

#include<iostream>
using namespace std; //std中包含关键字，cin,cout等
namespace spaceA{
    int x;
    int y;
}
int main()
{
    spaceA::x = 8;  //1.名字空间名称::局部内容名称
    cout<<spaceA::x<<endl;
    spaceA::y = 9;  
    cout<<spaceA::y<<endl;
    
    // 2.using namespace 名字空间名称
    using namespace spaceA;
    x = 8;
    y = 9;
    cout<<x<<y;
    // 3.using spaceB
    using spaceA::x;
    x=4;
    cout<<x;
    return 0;
}

2.2数据类型

基本数据类型：整型，实型，字符型，布尔型，无值型

非基本数据类型：复合数据类型，构造数据类型

2.3 new和delete

指针变量的定义：

注意：ip 是指针变量， *ip是解引用（不要和int *ip 弄混）

int num ;
int *ip = &num; //定义一个整型指针变量
*ip = 4;  //解引用
// 解引用操作仅适用于那些确实指向了某个对象的有效指针

为什么指针变量在定义时要说明其类型？

指针变量保存的是地址，如一个整型指针变量是4个字节，要访问内存时，要将4个字节全部读出来时才有意义。

new        &       delete

        new 内存分配

        delete 释放new分配的存储空间
#include<iostream>
using namespace std;
int main(){
    int *p;
    p = new int; //申请一个整型空间
    *p = 7;
    cout<<*p<<endl;
    delete p;   

    return 0;
}
注意：定义和使用指针变量的方法

2.4引用

2.5函数

2.6参数传递

1.传值参数：

当初始化一个非引用类型的变量时，初始值被拷贝给变量，此时，变量的改动不会影响初始值。

当执行指针拷贝操作时，拷贝的是指针的值。拷贝之后，两个指针是不同的指针。

2.传引用参数

通过使用引用形参，允许函数改变一个或多个实参的值。引用形参绑定初始化它的对象

2.7内联函数

调用函数一般比求等价表达式的值要慢一些。在大多数机器上，一次函数调用包含这一系类的工作: 调用前要保存寄存器，并在返回时恢复；可能需要拷贝实参；程序转换到另一个位置继续执行。

2.8重载函数

2.9异常处理

try & throw & catch ....

类与对象

3.1类

类是具有相同属性和方法的一类对象集合的抽象

定义类就是对问题抽象和封装的过程。

类的定义：

关键：在类体外定义成员函数

3.2对象

对象是类的实例或实体

对象成员的访问：

point *point_p1;
point_p1 = &p1;
//定义一个指针，并且赋予指针意义，指向p1的地址
point_p1->set(1,2); //使用指针访问成员变量
p1.show();
(*point_p1).set(2,3); //使用对象访问成员
(&p1)->show()

3.3类的界面和实现

point.h & point.cpp 分开实现

//point.cpp
#include<iostream>
#include "point.h"
using namespace std;
void point::set1(int a,int b)
{
    x = a;
    y = b;
}
void point::show()
{
    cout<<x<<y<<endl;
}

//point.h
class point
{
private:
    int x,y;
public:
    void set1(int a,int b);
    void show();
};

//main.cpp
#include<iostream>
#include "point.h"
using namespace std;
int main(){
    point p1;
    p1.set1(1,1);
    p1.show();
    return 0;
}

3.3.1构造函数

构造函数是一种特殊的成员函数，对象的创建和初始化由它来完成。

1.构造函数不能是私有的；

2.构造函数可以重载，可以带一个参数，也可以不带参数。

3.3.2成员初始化列表

冒号后面就是成员初始化表：可以使用引用&，

3.3.3具有默认参数的构造函数

3.3.4析构函数（重点）

特点：释放对象，回收空间

自动被调用

析构函数自动被调用

3.3.5拷贝构造函数

定义：

特点：

3.3.6浅拷贝和深拷贝

能满足已知对象去初始化未知对象，用默认的拷贝构造函数可以实现，浅拷贝
如果一个类中含有指针类型的变量，浅拷贝会出现错误，需要自己写拷贝构造函数。这种拷贝就是深拷贝。

#include<iostream>
#include<cstring>
using namespace std;
class String
{
    char *buf;  //用来存放字符串的
    int length;//表示字符串的长度
public:
    String()    //不带参数的构造函数，创建一个空串
    {
        length = 0;    //串长为0
        buf = new char; 
        buf[0] = '\0';//字符串的结束符
    }
    String(char *s)   //用字符串初始化
    {
        length=strlen(s);
        buf = new char[length+1];//开辟空间，对一个空间放'\0'字符串的结束符
        strcpy(buf,s);
    }
    //拷贝构造函数
    String(const String &s)
    {
        
        length = s.length;
        //buf = s.buf; 错误的方法
        buf = new char[length+1];
        strcpy(buf,s.buf);
        cout<<"我是默认拷贝构造函数,深拷贝"<<endl;
    }
    ~String()      //析构函数，回收空间
    {
        delete[] buf;
    }
    void show()
    {
        cout<<buf<<endl;
    }
};
int main()
{
    String s1((char *)"helloworld!"); //需要强制类型转换一下
    s1.show();
    String s2 = s1; //拷贝一下
    s2.show();
    return 0;
}

拷贝成功

3.4this指针

用途:

①区分成员和非成员

上面的方式是不对的，正确的赋值方式

② 类的方法需要返回当前对象的引用

3.5向函数传递对象

3.6类的静态成员

#include<iostream>
using namespace std;
class student{
    public:
        static int count;
        static double total;
        student(double score)
        {
            this->score = score;
            count++;
            total+=score;
        }
        static double getAverage(){
            return total/count;
        }
    private:
        double score;
};
int student::count = 0;
double student::total = 0;  //初始化成员

int main()
{
    student s1(70),s2(90);
    cout<<s1.getAverage()<<endl;  //通过对象去访问
    cout<<student::getAverage()<<endl; // 通过类名访问，static 类里面的静态全局变量
    return 0;
}

3.7类的友元

//一个类的成员函数作为另一个类的友元使用
#include<iostream>
using namespace std;
class girl; //声明一下
class boy
{
    string name;
    public:
        boy(string nm)
        {
            name = nm;
        }
        void introduce()
        {
            cout<<"i am "<<name<<endl;
        }
        void introducefriend(girl &x);  
};
class girl
{
    string name;
    public:
    girl(string nm)
    {
        name = nm;
    }
    void introduce()
    {
        cout<<"i am"<<name<<endl;
    }
    friend void boy::introducefriend(girl &x);
    //声明boy的成员函数introducefriend是girl的友元函数
};
void boy::introducefriend(girl &x)
{
    cout<<"she is "<<x.name<<endl;
}
int main()
{
    boy boy1("tom");
    girl girl1("alice");
    boy1.introduce();
    boy1.introducefriend(girl1);

    return 0;
}