C++面向对象基础

已于 2024-09-27 18:51:25 修改
阅读量406 收藏 4
点赞数 11
文章标签： c++ 算法 开发语言
于 2024-09-27 18:50:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_64136247/article/details/142600098
版权

目录

一.作用域限定符

1.名字空间

2.类内声明，类外定义

二.this指针

1 概念

2.功能

2.1 类内调用成员

2.2 区分重名的成员变量和局部变量

2.3链式调用

三.stastic关键字

1.静态局部变量

2 静态成员变量

3 静态成员函数

4 单例设计模式（了解）

四、const关键字（掌握）

1 const修饰成员函数

2.const修饰对象

3.const修饰成员变量

4 const修饰局部变量

5.constexpr 常量表达式

一.作用域限定符

1.名字空间

#include <iostream>
using namespace std;
int a = 2;
namespace my_space
{
    int a = 3;
    int b = 4;
}
using namespace my_space;
int main()
{
    int a = 1;
    cout << a << endl;  // 就近原则 打印1
    cout << ::a << endl; // ::匿名名字空间。2
    cout << my_space::a << endl;    // 3
    cout << b << endl;
    return 0;
}

2.类内声明，类外定义

#include <iostream>
using namespace std;
class Demo
{
public:
    // 类内声明
    Demo();
    void test(string str);
};
Demo::Demo()
{
    cout << "构造函数" << endl;
}
void Demo::test(string str)
{
    cout << "string =" << str << endl;
}
int main()
{
    Demo d;
    d.test("test");
    return 0;
}

二.this指针

1 概念

this指针是一个特殊的指针，指向当前类对象的首地址。

成员函数（包括构造函数与析构函数）中都有this指针，因此this指针只能在类内使用。实际上this指针指向的就是当前运行的成员函数所绑定的对象。

#include <iostream>
using namespace std;
class Test
{
public:
    void test_this()
    {
       cout << this << endl;
    }
};
int main()
{
    Test t1;
    cout << &t1 << endl;    // 0x61fe8f
    t1.test_this();         // 0x61fe8f
    Test t2;
    cout << &t2 << endl;    // 0x61fe8e
    t2.test_this();         // 0x61fe8e
    Test *t3 = new Test;
    cout << t3 << endl;     // 0x7c27c8
    t3->test_this();        // 0x7c27c8
    delete t3;
    return 0;
}

2.功能

2.1 类内调用成员

● 成员（变量+函数）必须由对象调用。类中成员调用都依赖于this指针。通常由编译器自动添加。

#include <iostream>
using namespace std;
class Test
{
private:
    string name;
public:
    Test(string n)
    {
        // 编译器默认添加this指针指向当前对象
        this->name = n;
    }
    string get_name()
    {
       return this->name;
    }
};
int main()
{
    Test t1("zhangsan");
    cout << t1.get_name() << endl;
    Test t2("lisi");
    cout << t2.get_name() << endl;
    return 0;
}

2.2 区分重名的成员变量和局部变量

#include <iostream>
using namespace std;

class Test
{
private:
    string name;
public:
    Test(string name)//:name(name)    // 构造初始化列表区分
    {
        // 通过this指针在函数体中区分
        this->name = name;
    }
    string get_name()
    {
       return this->name;
    }
};

int main()
{
    Test t1("zhangsan");
    cout << t1.get_name() << endl;

    Test t2("lisi");
    cout << t2.get_name() << endl;
    return 0;
}

2.3链式调用

支持链式调用的成员函数特点：

● 当一个成员函数的返回值是当前类型的引用时，往往表示这个函数支持链式调用。● return后面是*this

#include <iostream>
using namespace std;
class Test
{
private:
    int val = 0;
public:
    Test &add(int i)
    {
        val += i;   // val = val + i;
        return *this;
    }

    int get_val()
    {
        return val;
    }
};
int main()
{
    Test t1;
    t1.add(1);
    t1.add(2);
    t1.add(100);
    cout << t1.get_val() << endl;
    Test t2;
    // 链式调用
    cout << t2.add(2).add(32).add(200).get_val() << endl; // 234
    // cout << t2.get_val() << endl;    // 2
    return 0;
}

三.stastic关键字

1.静态局部变量

使用static修饰局部变量，这样的变量就是静态局部变量。
静态局部变量在第一次调用时创建，直到程序结束后销毁，同一个类所有对象共用这一份静态局部变量。

#include <iostream>
using namespace std;
class Test
{
public:
    void func()
    {
        int a = 1;
        static int b = 1;   // 静态局部变量

        cout << "a=" << ++a << " " << &a << endl;
        cout << "b=" << ++b << " " << &b << endl;
    }
};
int main()
{
    Test t1;
    t1.func();  // 2 2

    t1.func();  // 2 3

    Test t2;
    t2.func();  // 2 4

    return 0;
}

2 静态成员变量

使用static修饰成员变量，这样的变量就是静态成员变量。

静态成员变量需要类内声明，类外初始化。

一个类的所有对象共用一份静态成员变量，虽然静态成员变量可以使用对象调用，但是更建议使用类名直接调用。静态成员变量可以脱离对象使用，在程序开始运行时就开辟内存空间直到程序结束后销毁。

更推荐使用类名进行调用。代码的可读性更好。

#include <iostream>
using namespace std;

class Test
{
public:
    int a = 1;
//    static int b = 2; // 错误 ，静态成员变量需要内类声明，类外初始化
    static int b;
};

int Test::b = 1;    // 类外初始化

int main()
{
    cout << Test::b << " " << &Test::b << endl; // 1 0x403004

    Test t1;
    Test t2;
    cout << t1.a++ << " " << &t1.a << endl; // 1 0x61fe8c
    cout << t2.a++ << " " << &t2.a << endl; // 1 0x61fe88

    cout << "-----------------" << endl;

    cout << t1.b++ << " " << &t1.b << endl; // 1 0x403004
    cout << t2.b++ << " " << &t2.b << endl; // 2 0x403004

    cout << Test::b << " " << &Test::b << endl; // 3 0x403004

    return 0;
}

3 静态成员函数

使用static修饰成员函数，这样的函数就是静态成员函数。

与静态成员变量相似的有：

● 都可以通过类名直接调用，也可以通过对象调用（推荐使用类名直接调用）

● 都可以脱离对象使用。

静态成员函数没有this指针，不能在静态成员函数中调用同类中其他非静态成员，但是静态成员函数可以调用静态成员。

#include <iostream>
using namespace std;
class Test
{
public:
    void func0()
    {
//        func1();
        cout << "非静态成员函数" << endl;
    }
    // 静态成员函数
    static void func1()
    {
//        func0(); // 错误，静态成员函数没有this指针
        cout << "静态成员函数1" << endl;
    }
    static void func2()
    {
//        func1();
        cout << "静态成员函数2" << endl;
    }

};
int main()
{
//    Test::func1();  // 通过类名直接调用
    Test t1;
    t1.func0();
//    t1.func1();
    t1.func2();
    return 0;
}
● 如果要在静态成员函数内调用非静态成员的属性，可以通过参数将对象传进来，因为静态成员函数内没有this指针。例如： 
#include <iostream>
using namespace std;

class Test
{
public:
    void func0()
    {
//        func1();
        cout << "非静态成员函数" << endl;
    }

    // 静态成员函数
    static void func1(Test &t)
    {
//        t.func0();
        Test t3;
        t3.func0();
//        func0(); // 错误，静态成员函数没有this指针
        cout << "静态成员函数1" << endl;
    }

    static void func2()
    {
//        func1();
        cout << "静态成员函数2" << endl;
    }
};

int main()
{
//    Test::func1();  // 通过类名直接调用
    Test t1;
    t1.func0();
    t1.func1(t1);
    t1.func2();
    return 0;
}

4 单例设计模式（了解）

设计模式是一套被反复使用，多人知晓的，经过分类的，代码设计经验的总结。通常用于面向对象的语言，如：Java、C++、C#。
 

#include <iostream>
using namespace std;

// 单例设计模式
class Singleton
{
private:
    Singleton(){}
    Singleton(const Singleton&s){}
    static Singleton *instance; // 静态成员变量指针
public:
    // 静态成员函数
    static Singleton* get_instance()
    {
        if(instance == NULL)
        {
           instance = new Singleton;
        }
        return instance;
    }

    static void delete_instance()
    {
        if(instance != NULL)
        {
            delete instance;
            instance = NULL;
        }
    }

};

Singleton * Singleton::instance = NULL;

int main()
{
    Singleton *s1 = Singleton::get_instance();
    Singleton *s2 = Singleton::get_instance();
    cout << s1 << endl;
    cout << s2 << endl;

    return 0;
}

四、const关键字（掌握）

1 const修饰成员函数

const修饰的成员函数，表示常成员函数。

特性如下：

● 可以调用成员变量，但是不能修改成员变量的值

● 不能调用非const修饰的成员函数，哪怕这个函数没有修改成员变量。

建议只要成员函数不修改成员变量就使用const修饰。比如：show、print等函数。

#include <iostream>
using namespace std;

class Demo
{
private:
    int a;
public:
    Demo(int a)
    {
        this->a = a;
    }

    void func0()
    {
        cout << get_demo() << endl;
        cout << "哈哈哈哈哈哈" << endl;
    }


    int get_demo()const
    {
        return a;
    }

    void test()const
    {
//        a++; // 错误 const修饰的成员函数，不能修改成员变量
        cout << a << endl;  // 可以调用
//        func0(); // 错误 const修饰的成员函数，不能调用非const修饰的成员函数

        cout << get_demo() << endl;
    }
};

int main()
{
    Demo demo(1);
    cout << demo.get_demo() << endl;
    demo.func0();
    demo.test();

    return 0;
}

2.const修饰对象

const修饰的对象被称为常量对象，这种对象的成变量无法被修改，也无法调用非const修饰的成员函数。 
#include <iostream>
using namespace std;

class Demo
{
private:

public:
    int a;
    Demo(int a)
    {
        this->a = a;
    }

    void func0()
    {
//        cout << get_demo() << endl;
        cout << "哈哈哈哈哈哈" << endl;
    }


    int get_demo()const
    {
        return a;
    }

    void test()const
    {
//        a++; // 错误 const修饰的成员函数，不能修改成员变量
        cout << a << endl;  // 可以调用
//        func0(); // 错误 const修饰的成员函数，不能调用非const修饰的成员函数

        cout << get_demo() << endl;
    }

};

int main()
{
//    const Demo demo(1); // 常量对象
    Demo const demo(1); // 两种初始化的方式，等效于上一行

//    demo.a = 2; // 错误const修饰的对象，无法修改成员变量
    cout << demo.a << endl; // 可以调用但是无法修改

//    demo.func0(); // 错误const修饰的对象，无法调用非const修饰的成员函数

    cout << demo.get_demo() << endl;

    return 0;
}

3.const修饰成员变量

const修饰的成员变量为常成员变量，表示改成员变量的值无法被修改。

常成员变量存在两种初始化的方式：

● 直接赋值

声明之后赋值：

● 构造初始化列表

上述两种方式同时使用时，前者失效，以后者为准。

#include <iostream>
using namespace std;

class Demo
{
private:
    const int a = 1;    // 直接赋值
    const int b = 2;
    const int c = 3;
public:
    // 构造初始化列表赋值
    Demo(int a,int b,int c):a(a),b(b),c(c){}

    void show()
    {
        cout << a << " " << b << " " << c << endl;
    }

    void test()
    {
//        a++;  // 错误，常成员变量无法被修改
//        b++;
//        c++;
    }

};

int main()
{
    Demo d(10,20,30);
    d.show();
    d.test();

    return 0;
}

4 const修饰局部变量

const修饰局部变量，表示该局部变量不可被修改。

这种方式常用于修饰引用参数。

#include <iostream>
using namespace std;

class Demo
{
private:
    const int a = 1;    // 直接赋值
    const int b = 2;
    const int c = 3;
public:
    // 构造初始化列表赋值
    Demo(int a,int b,int c):a(a),b(b),c(c){}

    void show()
    {
        cout << a << " " << b << " " << c << endl;
    }

    void test(const int &f)
    {
//        f++; // 错误
        cout << f << endl;
        const int e = 1;
//        e++; // 错误，const修饰的局部变量，无法被修改
    }

};

int main()
{
    Demo d(10,20,30);
    d.show();
    d.test(2);

    return 0;
}

5.constexpr 常量表达式

#include <iostream>

using namespace std;

class Test
{
public:
    constexpr static int a = 1; // a=1在编译期确定
//    constexpr int b = 2; 错误
    const int c = 3;
};
在上面的例子中，a不需要配合任何对象使用，而对象是在程序运行期间创建的，因此a可以被constexpr修饰，表示在编译期确定；反之b需要在对象创建之后才能创建，因此不能被constexpr修饰。

被constexpr修饰的内容表示在编译期间可以确定，C++中部分代码是需要在编译期间确定。

#include <iostream>
#include <array> // 后面要学习的一个头文件

using namespace std;

// 表示是否可以在编译期间计算出返回值
constexpr int calc_len(int i)
{
    return i+5; // 随便写的计算规则
}

int main()
{
    // 5表示创建的arr对象的长度，必须在编译期间确定
    array<int,5> arr;

    // 编译期间可以计算出结果为6，正确
    array<int,calc_len(1)> arr2;

    int i = 1;
    // 编译期间无法计算出最后结果，报错
//    array<int,calc_len(i)> arr3; 错误

    return 0;
}
嵌入式----HR
关注
C++基础：面向对象编程
weixin_58368590的博客
05-23 1271
1. 面向过程： 当软件规模超过一定的尺度后，采用结构化程序设计，其开发和维护就越来越难空值。其根本原因就在于面向过程的结构化程序设计的方法与现实世界往往不一致，结构化程序的思想往往很难贯彻到底。 在结构化设计中，往往采用的是“自顶向下，逐步细化”的思想。具体操作方法是模块化，是按照功能来分的，所以也称为功能块（函数）。在c++中称为一个函数，一个函数解决一个问题，即实现一个功能或一个操作。 在模块化的思想中已经出现了封装的概念，这个封装是将数据封装到模块中，即局部变量。电脑这是很不彻底的，因为模块是
《C++面向对象程序设计》✍千处细节、万字总结（建议收藏）
热门推荐
像写诗一样优雅地写代码~
06-04 66万+
《C++面向对象程序设计》✍千处细节、万字总结 文章目录《C++面向对象程序设计》✍千处细节、万字总结一、面向对象程序设计二、C++基础2.1 C++的产生和特点2.2 一个简单的C++示例程序2.3 C++在非面向对象方面对C语言的扩充输入和输出cinconst修饰符void型指针内联函数带有默认参数值的函数函数重载作用域标识符"::"强制类型转换new和delete运算符引用三、类和对象（一）3.1 类的构成3.2 成员函数的定义3.3 对象的定义和使用3.4 构造函数与析构函数构造函数成员初始化列表
面向对象程序（C++）设计基础
铁路十六宿舍的博客
02-12 1791
本文由浅入深的对面向对象语言涉及的概念进行了详解，以C++给读者针对重要的概念举例，帮助读者能够快速实现从过程语言（c）到面向对象语言的编程思路转换。
C++面向对象程序设计基础知识点
Joker700的博客
12-12 2907
在学习过C语言以及c++的基础概念后相信大家对于面向过程的程序设计已经得心应手，那么今天我们所提到的就是c++编程思想中的面向对象程序设计，本篇文章将为大家介绍一些关于C++面向对象程序设计的基础知识点。
C++面向对象
qq_45806136的博客
02-13 4102
*从存储空间的角度考虑：**构造函数是在实例化对象的时候进行调用，如果此时将构造函数定义成虚函数，需要通过访问该对象所在的内存空间才能进行虚函数的调用（因为需要通过指向虚函数表的指针调用虚函数表，虽然虚函数表在编译时就有了，但是没有虚函数的指针，虚函数的指针只有在创建了对象才有），但是此时该对象还未创建，便无法进行虚函数的调用。所以构造函数不能定义成虚函数。**从使用的角度考虑：**虚函数是基类的指针指向派生类的对象时，通过该指针实现对派生类的虚函数的调用，构造函数是在创建对象时自动调用的。
C++ 面向对象程序设计
2201_75772333的博客
05-03 3733
在面向对象的思想中，我们把对象作为程序的基本单元，一个对象包含了数据和操作数据的函数。当然，一个应用程序会包含多个对象，通过多个对象的相互配合即可实现应用程序所需的功能，这样当应用程序功能发生变动时，只需要修改个别对象就可以了，使代码更容易维护。面向对象的程序设计思想可以帮助我们创建结构良好的，可复用的代码，更好地描述和理解真实世界的问题。封装可以隐藏对象的内部表示，只通过对象的方法暴露必要的操作和功能。这使得新类可以复用和扩展已存在的类的代码，提高了代码的复用性，并能够表达类之间的"is-a"关系。
【C++】面向对象基础篇
我宣布个事的博客
01-10 2719
本文通过代码示例，基本涵盖所有C++基础内容
c++面向对象程序设计
linzixi0220的博客
01-22 4856
什么是对象？ 现实生活中的各种物品，水瓶，铅笔，书本，苹果，书包这些都是对象，对象可以是任何东西。而在程序设计中，对象实际上就是变量，在程序设计中的各种变量，不管是整型、实数型、字符型、布尔型都是对象。一个程序就是一大串的对象互相通过传递信息告诉彼此该怎么做。每一个对象都有他自己的内存，这个内存又是由其他对象组成。 面向过程和面向对象 c语言是面向过程的程序设计，而c++则在c语言的基础上增加了面向对象的概念。面向过程首先是分析问题，然后根据算法将解题步骤一步一步地用c语言的语句描述出来，这是一种以“
浅谈C++的面向对象
qq_46046431的博客
05-28 3358
文章目录前言如何理解C++面向对象编程封装继承多态拓展：虚函数的一点小规则总结 前言 注：我的笔记风格，可能不会特别官方，不会晦涩难懂，而是以一个初学者能看懂的方式把知识呈现出来，用最简单的语言把抽象的概念表达出来～ 经常谈到面向对象这四个字，那么下面以C++为例，谈一下我对面向对象的理解，请往下看～ 如何理解C++面向对象编程 看以下三点： 1.c++面向对象编程就是把一切事物都变成一个个对象，用属性和方法来描述对象的信息，比如定义一个猫对象，猫的眼睛、毛发、嘴巴就可以定义为猫对象的属性，猫的叫声
C++面向对象程序设计课程大作业-通讯录管理系统
05-21
本项目是学习C++面向对象编程的实战案例，通过设计和实现通讯录管理系统，学生可以深入理解面向对象编程的概念和技巧，并提升解决问题的能力。同时，项目的完整流程，包括需求分析、设计、编码、测试，也能帮助学生...
《C++面向对象程序设计》第2版编程题答案
02-26
《C++面向对象程序设计》是C++编程领域的一本经典教材，由清华大学出版社出版，龚晓庆、付丽娜等多位专家共同编著。这本书深入浅出地讲解了C++语言的核心概念，特别是面向对象编程（OOP）的思想和技术。第二版在第一...
C++面向对象程序设计_C++_C++面向对象_ppt_
10-04
这个PPT对于初学者来说是一份宝贵的资源，它不仅涵盖了C++面向对象的基础知识，还可能深入到一些高级主题，帮助学习者全面理解并掌握面向对象编程在C++中的实践应用。通过学习和理解这些内容，开发者将能够利用C++的...
c++ 面向对象设计五大原则
08-18
C++ 面向对象设计五大原则 C++ 面向对象设计五大原则是面向对象编程（OOP）中一个非常重要的...C++ 面向对象设计五大原则是面向对象设计的基础，遵循这五大原则可以使我们的程序设计更加合理、更加灵活、更加可维护。
C++ 异步编程中：future与promise、packaged_task、async
zxf347085420的博客
09-23 964
std::launch::async | std::launch::deferred参数：是默认行为(可省略)。=》std::async真的是来帮忙的，你不用再想到底该怎么用std::future、std::promise和 std::packaged_task了，在已经有了td::future、std::promise和std::packaged_task的情况下，实现异步或多线程间通信，事实上std::promise::set_xxx函数会改变std::promise的状态为ready，
【C++】拆分详解 - string类
bubble_shadow的博客
09-23 985
string类的文档介绍注：此处及下文部分，蓝色下划线标识文本均为超链接，点击即可跳转字符串是表示字符序列的类标准的字符串类提供了对此类对象的支持，其接口类似于标准字符容器的接口，但添加了专门用于操作单字节字符字符串的设计特性。string类是使用char(即作为它的字符类型，使用它的默认char_traits和分配器类型(关于模板的更多信息，请参阅basic_string)。
c++ 使用 Graham 扫描的凸包（Convex Hull using Graham Scan）
最新发布
csdn_aspnet的专栏
09-26 855
对于剩余的点，我们跟踪最近的三个点，并找到它们形成的角度。如果这些点的方向（按相同顺序考虑它们）不是逆时针的，我们丢弃 c，否则我们保留它。因此，第六步逐个处理点需要 O(n) 时间，假设堆栈操作需要 O(1) 时间。总体复杂度为 O(n) + O(nLogn) + O(n) + O(n)，即 O(nLogn)。在每个步骤中，算法都会检查添加到凸包中的最后两个点是否形成右转。格雷厄姆扫描算法是一种简单而有效的算法，用于计算一组点的凸包。凸包用于各种计算几何算法，例如查找最近的点对和计算一组点的直径。
Codeforces Round 973 (Div. 2) C. Password Cracking
puzhaoyu的博客
09-21 657
说明已经构建到了最右边，那么开始向左边构建。（写这题的时候一直不对，后来发现是忘记cin >> t了，归根结底还是不熟悉交互式编程的输入输出方式）猜一串二进制密码，每次可询问某串字符是否是密码的子串。从左到右不断构建ans字符串，每次不是加。，这可以通过询问得到。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值