精华内容
下载资源
问答
  • c++静态

    万次阅读 2015-03-09 19:51:12
    C++静态

    今天在写C++的一个随机数生成器时,看到所有成员变量和成员函数都是static类型。想到这个整个类其实不需要实例,或者说只需要一份(产生随机数应该不需要多个实例呀~),干嘛不直接搞个static静态类呢?
    于是写了这个实验一下:

    #include <iostream>
    using namespace std;
    
    static class Test
    {
    public:
        static int GetData()
        {
            return data;
        }
    private:
        static int data;
    };
    
    int Test::data = 3;
    
    int main()
    {
        cout<<Test::GetData()<<endl;
        return 0;
    }

    倒是可以编译运行,但是会报一个warning
    warning C4091: ‘static ’ : ignored on left of ‘Test’ when no variable is declared
    这是什么意思呢?后来查了一下,在msdn社区上看到了解释:

    c++根本就没有静态类这个东西,这么写编译器会认为其实是想做
    static class Test
    {

    }tt;
    这个static关键字是针对tt而非Test的。但是这里的实际情况是没有变量tt,所以编译器给出了warning并且忽略了static关键字

    msdn社区:
    https://social.msdn.microsoft.com/Forums/en-US/75cc5b2e-0dd1-4efc-8d5a-1f497679d8e4/static-classes-causing-warnings

    展开全文
  • [code=c] class Cbook { int age; void say() ...在C++类Cbook中声明了一个 整型变量age和say方法, 访问修饰符如果不写的话,它默认的是什么,看了好多帖子,说的都不一样,求大神给出标准答案!!!
  • C++类方法调用

    千次阅读 2019-10-29 09:23:09
    C++类内部方法调用时,一般都是先去定义一个类的变量,实例化之后再通过类对象去调用类内部的函数。在项目中发现另一种比较方便的方法,不需要定义类对象,话不多说直接上代码。 实例代码如下: #include <...

    在C++类内部方法调用时,一般都是先去定义一个类的变量,实例化之后再通过类对象去调用类内部的函数。在项目中发现另一种比较方便的方法,不需要定义类对象,话不多说直接上代码。

    实例代码如下:

    #include <iostream>
    using namespace std;
    
    class A{
    public:
        A(int iNum){ i = iNum; }
        void    readName(){cout<<"i = "<<i<<endl;}
    private:
        int i;
    	
    public:
        static A*	_obj(){ return _object; }
        static void	_InitObj();
        static void	_FreeObj();
        void    read_it(){cout<<"it = "<<it<<endl;}
    	
    private:
        static A* _object;
        static int it;
    };
    
    void A::_InitObj()
    {
        A::_object = new A(4);
    }
    
    void A::_FreeObj()
    {
        if(A::_object != NULL)
        {
    	delete _object;
    	A::_object = NULL;
        }
    }
    
    A* A::_object = NULL;
    int A::it = 9;
    
    int main()
    {
        A::_InitObj();
    	
        A::_obj()->readName();
        A::_obj()->read_it();
    	
        A::_FreeObj();
    	
        return 0;
    }

    上述代码执行结果:

    通过上述代码可以清楚的知道,通过在类内部定义静态变量向外部类提供相应的接口去调用类的内部方法,该办法确实非常实用。

    展开全文
  • ``` class Test { void func1() const {} void func2() const & {} void func3() const && {} void func4() {} void func5() & ...以各个函数有什么区别?函数声明后面加&有什么用?
  • C++类模板

    万次阅读 2016-02-13 20:49:51
    C++类模板 #include using namespace std; templateclass numtype> //声明一个模板,虚拟类型名为numtype class compare //类模板名为compare { public: compare(numtype x,numtype y)

    与函数模板相同,往往有时候对好几个功能相似的类,可以使用类模板。

    C++类模板

    #include <iostream>
    using namespace std;
    template<class numtype> //声明一个模板,虚拟类型名为numtype
    class compare //类模板名为compare
    {
    public:
        compare(numtype x,numtype y)
        {
            this->x=x;
            this->y=y;
        }
    
    
        numtype max()
        {
            return x>y?x:y;
        }
    
    
        numtype min()
        {
            return x<y?x:y;
        }
        numtype mean();
    private:
        numtype x,y;
    };
    template<class numtype>
    numtype compare<numtype>::mean()
    {
        return (x+y)/2;
    }
    
    
    int main()
    {
        compare<int> comp1(1,2);
        cout << "max is" << comp1.max() << endl;
        cout << "min is" << comp1.min() << endl;
        compare<float> comp2(1.5,2.1);
        cout << "max is" << comp2.max() << endl;
        cout << "min is" << comp2.min() << endl;
        cout << "mean is" << comp2.mean() << endl;
        compare<char> comp3('a','b');
        cout << "max is" << comp3.max() << endl;
        cout << "min is" << comp3.min() << endl;
        return 0;
    }
    
    

    1.1在声明类模板前要增加一行 template<class 类型参数名>
    1.2 numtype只是一个虚拟类型参数名。
    1.3在建立对象时,如果指定为int则为int型,指定为float,则为float型。实现“一类多用”
    1.4因为类模板包含参数,所以被称为参数化的类。
    1.5如果说类是对象的抽象,那么类模板是类的抽象,类是类模板的实例。
    1.6使用类模板:
    compare <int> cmp1(1,2);
    1.7在类外使用类模板函数
    template <class numtype>
    numtype compare<numtype>::mean()
    {
    return (x+y)/2;
    }

    C++类模板的使用步骤

    1.1先写出一个实际的类,而不是类模板。
    1.2将此类中的int等改成一个指定的虚拟类型名。
    1.3在类的声明前加一行:
    template <class 虚拟化参数(如:numtype)>
    1.4用类模板定义对象时用以下形式:
    compare <int> comp1(1,2);
    1.5在模板外定义成员函数,应写成类模板的形式。
    template<class numtype>
    numtype compare<numtype>::mean(){}

    C++类模板其他

    1.1类模板的类型参数可以有一个或者多个,每个类型前面都必须加class,如:
    template<class T1,class T2>
    class someclass
    {...};
    在定义对象的时候分别带入实际的类型名,如:
    someclass <int,double> obj;
    1.2和使用类一样,在使用类模板的时候要注意其作用域,只能在其有效作用域内用它定义对象。
    1.3模板可以有层次,一个类模板可以作为基类,派生出派生类的模板类。




    
    
    
    
    展开全文
  • 【C++】C++类的学习(一)——初识类

    万次阅读 多人点赞 2018-03-24 13:57:55
    ... 前言  C++在C语言的基础上做了一些改进,使得C++具有了面向对象编程(Object Oriented Programming,OOP)的特性。...可以说学习了C++却不会使用的话,那么就没有学习到C++的精髓。  在接...

     

    fishing-panhttps://blog.csdn.net/u013921430转载请注明出处】

    前言

           C++在C语言的基础上做了一些改进,使得C++具有了面向对象编程(Object Oriented Programming,OOP)的特性。其中最重要的改进就是提供了类的概念。可以说学习了C++却不会使用类的话,那么就没有学习到C++的精髓。

           在接下来的几篇博文中,我将梳理一下自己学习C++中类的学习心得。类中涵盖的知识点非常庞杂,我不会把每个细节都写出来,我会沿着主线由浅入深来梳理,希望对看到这些博文且想了解类的你有所帮助。

     

    初探类

          类的基本思想是数据抽象封装。数据抽象是一种把接口和实现分离的编程技术。类的接口包括用户所能够执行的操作,类的实现包括类的数据成员、负责接口实现的函数体和各种私有函数。

          封装实现了类的接口和实现的分离。封装隐藏了类的实现,封装过后,用户只能访问类的接口,而不能访问类的实现。

         类是一种将抽象转换为用户定义类型的C++工具,它将数据表示和操纵数据的方法组合成一个整体。例如一个日常生活时间类,时间对象有两个属性,小时和分钟,根据需要应该能够对每个日常事务所花的时间进行操作和显示。操作和显示就需要类的接口函数。

          一般的类由两部分组成:

          1. 类声明:以数据成员的方式描述数据部分,以成员函数(被称为方法)的方式描述接口函数。

          2. 类方法定义:描述如何实现类成员函数。

          简单地说,类声明给出了类的框架,而方法定义给出了类的细节。

    私有成员与公有成员

           在下面的代码中声明了一个Time类;类中有两个关键字privatepublic,它们描述了程序对类的成员的访问控制。由于隐藏数据是OOP的主要目的之一,所以数据成员一般放在private部分,而接口函数则放在public部分。

    #ifndef MYTIME_H
    #define MYTIME_H
    #include <iostream>
    
    using namespace std;
    
    class Time
    {
    	//----------私有成员,类中的成员默认是私有的
    private:
    	int hours;
    	int mintues;
    
    	//----------共有成员
    public:
    	Time();                                                       //默认构造函数
    	Time(int h, int m = 0);                                       //显式构造函数
    	Time(const Time &);                                           //拷贝构造函数
    	~Time();                                                      //析构函数
    	void AddMin(int m);
    	void AddHour(int h);
    
    	void reset(int h = 0, int m = 0);
    
    	//------展示函数show()     //在const函数中不可调用非const函数成员
    	void Time::show() const
    	{
    		cout << "hours:" << hours << "  " << "mintues:" << mintues << "  "<<endl;
    	}
    
    };
    
    
    //-------时间重置,内联函数
    inline void Time::reset(int h, int m)
    {
    	hours = h;
    	mintues = m;
    }
    
    
    #endif

           使用类对象的程序可以直接访问类的公有成员,但是不能直接访问私有成员,要访问私有成员则需要公有成员间接地访问。例如在程序中定义一个Time类对象eating。可以通过eating访问公有成员show()函数,而不能直接用eating访问hours。

    Time eating(1, 45);
    
    eating.show();                      //合法;
    eating.hours;                       //非法,不能直接访问私有成员。

    注:类的成员默认是私有的,但是为了严谨一般还是用private关键字注明,而结构体的成员默认是公有的。

    成员函数的实现

    1.    在类外定义一个成员函数时,需要使用域解析运算符(::)来标识函数所属的类。这意味着,不同的类中,可以定义同样的成员函数而互不影响。

    例如:

    void Time::AddMin(int m)
    
    {
        mintues += m;
        hours += mintues / 60;
        mintues %= 60;
    }

    2.    在声明一个类时,可以将成员函数的定义直接放入类中,此时函数默认是一个内联函数,不需要添加域解析符。但是为了方便代码阅读,一般不会将成员函数直接在类中实现。

           在上面的代码中,成员函数show()就直接定义在了类的定义体中。

    3.    也可以将函数的实现写进类声明的头文件中,但是一定要添加inline关键字,在C++中的头文件(.h详解(2中曾经提到过原因,如果不让函数成为内联函数,当头文件被多个源文件引用时,会出现重定义。(有疑惑的可以点击上面的链接进入阅读博文)

           上面代码中的,reset()函数就是采用内联函数的方式定义在了类定义的头文件中。

    类对象使用类成员

       对象使用成员函数时使用成员运算符: .

       例如:Time的一个对象eating调用show()函数。

    eating.show();

    类的const成员

          当定义类的成员函数时,时常会出现const关键字是放在函数括号后面的情况,他的意思是这个函数不能修改调用它的那个对象的值。与返回值是否是常量无关。 为了保证数据的安全,在类的成员函数不修改对象的值时,应该尽量将成员函数定义为const成员函数。

    void Time::show() const    //const关键字被放在了函数名括号的后面
    {
    	cout << "hours:" << hours << "  " << "mintues:" << mintues << "  "<<endl;
    }

         定义一个const对象与定义一个const普通对象一样,在对象前加上const 关键字, const对象是无法调用非const成员函数的,以免非const成员函数修改const对象的数据,这无疑降低了程序出错的可能性,而非const对象是可以调用const成员函数的。以下面的代码为例。

    Time swiming(0, 45);                 //非const对象
    const Time study(8, 5);              //const对象只能调用const成员函数。
    study.reset(0,0);                    //非法,const对象无法调用非const成员函数。
    
    study.show();                        //合法,show()是const成员函数。
    swiming.show();                      //合法;

           当然了,在const函数中修改对象的值是非法的,编译器无法通过。

    成员初始化规则

    • const修饰的变量定义后就不能更改了,因此,需要使用初始化列表来初始化。
    • 引用在进行初始化后就不会再改变,因此,也需要使用初始化列表来初始化。
    • 数据成员是对象时候,需要调用构造函数进行初始化(继承时调用基类构造函数)
    • static与类有关,不需要使用初始化列表。
    • 指针的值在初始化后可以改变,即指向其它的存储单元,因此,也不要使用初始化列表。

     

    代码

          为了方便大家的理解,在这里贴出所有代码

    //----mytime.h
    #ifndef MYTIME_H
    #define MYTIME_H
    #include <iostream>
    
    using namespace std;
    
    class Time
    {
    	//----------私有成员,类中的成员默认是私有的
    private:
    	int hours;
    	int mintues;
    
    	//----------共有成员
    public:
    	Time();                                                       //默认构造函数
    	Time(int h, int m = 0);                                       //显式构造函数
    	Time(const Time &);                                           //拷贝构造函数
    	~Time();                                                      //析构函数
    	void AddMin(int m);
    	void AddHour(int h);
    
    	void reset(int h = 0, int m = 0);
    
    	//------展示函数show()     //在const函数中不可调用非const函数成员
    	void Time::show() const    //const关键字被放在了函数体的后面
    	{
    		cout << "hours:" << hours << "  " << "mintues:" << mintues << "  "<<endl;
    	}
    
    };
    
    
    //-------时间重置,内联函数
    inline void Time::reset(int h, int m)
    {
    	hours = h;
    	mintues = m;
    }
    
    
    #endif
    //--mytime.cpp
    
    #include <iostream>
    #include "mytime.h"
    
    using namespace std;
    
    //-------默认构造函数
    Time::Time()
    {
    	hours = mintues = 0;
    	cout << "调用默认构造函数" << endl;
    }
    
    //------显式的构造函数
    Time::Time(int h, int m) :hours(h), mintues(m)
    {
    	cout << "调用显式构造函数" << endl;
    }
    
    //------拷贝构造函数
    Time::Time(const Time &t)
    {
    	hours = t.hours;
    	mintues = t.mintues;
    	cout << "调用拷贝构造函数" << endl;
    }
    
    //------析构函数
    Time::~Time()
    {
    	cout << "调用了析构函数" << endl;
    }
    
    //-------小时相加
    void Time::AddHour(int h)
    {
    	hours += h;
    }
    
    //------分钟相加
    void Time::AddMin(int m)
    {
    	mintues += m;
    	hours += mintues / 60;
    	mintues %= 60;
    }
    //---test.cpp
    #include <iostream>
    #include "mytime.h"
    
    using namespace std;
    
    const void fun()
    {
    	cout << 1 << endl;
    }
    
    
    int main()
    {
    
    	Time eating(1, 45);
    
    	eating.show();                        //合法;
    	//eating.hours;                       //非法,不能直接访问私有成员。
    
    	Time swiming(0, 45);                   //非const对象
    	const Time study(8, 5);                //const对象只能调用const成员函数。
    	//study.reset(0,0);                    //非法,const对象无法调用非const成员函数。
    
    	study.show();                         //合法,show()是const成员函数。
    	swiming.show();                       //合法;
    
    	system("pause");
    	return 0;
    }

     

     

     

    运行结果

     

     

    结果分析

          上面的结果和代码中都可以看到构造函数,析构函数以及拷贝构造函数,因为这三种函数是类非常重要的成员函数,因此下次进行单独讲解。

     

    已完。。

    参考书籍《C++  Primer 第五版》、《C++ Primer Plus 第六版》

     

    相关博客

    【C++】C++类的学习(二)——构造函数、析构函数、拷贝构造函数以及this指针

    【C++】C++类的学习(三)——运算符重载与友元函数

    【C++】C++类的学习(四)——继承与虚函数

    【C++】C++类的学习(五)——纯虚函数与模板类

     

     

     

    展开全文
  • C++类模板和模板类

    万次阅读 多人点赞 2018-11-29 14:32:35
    C++通过模板来实现泛型支持。 1 基础的模板 模板,可以定义相同的操作,拥有不同数据类型的成员属性。 通常使用template来声明。告诉编译器,碰到T不要报错,表示一种泛型. 如下,声明一个普通的模板: ...
  • C++类的构成

    千次阅读 2016-11-14 20:14:55
    C++语言的对不同成员(数据成员和成员函数)定义了3个可视的层次:private段(缺省,只有中的成员函数可以访问该段的成员;public段,中成员函数、中的对象、派生的成员函数及对象都可以访问该段中的成员;...
  • C++类大小详尽讲解

    万次阅读 多人点赞 2018-05-04 17:37:04
    C++类的大小,是一个比较经典的问题,学过C++后,应该对类大小有清晰的认识,长话短说,本文精简凝练,我们进入正题!!!1.类的大小与什么有关系? 与类大小有关的因素:普通成员变量,虚函数,继承(单一继承,...
  • C++类对象和类指针的区别

    万次阅读 多人点赞 2019-04-17 20:57:28
    一篇转载率较高的帖子:C++ 对象和 指针的区别 大佬都不贴结果。。。。所以这里我给出代码和结果: #include<iostream> using namespace std; class Test{ public: int a; Test(){ a = 1; } }; ...
  • C++中的string用法简介

    万次阅读 多人点赞 2019-08-21 17:21:17
    本文主要介绍C++中的string的常见用法。 1. 概述 string是C++标准库的一个重要的部分,主要用于字符串处理。可以使用输入输出流方式直接进行string操作,也可以通过文件等手段进行string操作。同时,C++的算法库...
  • c++类的大小计算

    万次阅读 多人点赞 2017-06-01 23:01:02
    c++所占的大小计算并没有想象中那么简单,因为涉及到虚函数成员,静态成员,虚继承,多继承以及空等,不同情况有对应的nisan方式,在此对各种情况进行总结。 首先要明确一个概念,平时所声明的只是一种类型...
  • C结构体、C++结构体 和 C++类的区别

    千次阅读 多人点赞 2016-06-14 09:34:32
    C结构体、C++结构体基本相同,C++类主要是方法的实现。 结构体是数据类型的集合 类是数据类型加方法的集合,基本如此,更注重方法。 1.C的结构体和C++结构体的区别 (1) C的结构体内不允许有函数存在,...
  • C#调用托管C++类

    千次阅读 2020-04-02 11:37:28
    由于C#编写的是托管代码,编译生成微软中间语言,而C++代码则编译生成本地机器码(这种C++也有叫做本地C++或者非...但是用过这种方法的人都知道这种方法对于导出函数还可以但是却没法导出非托管C++类!非常的要命。...
  • C++学习大纲

    万次阅读 多人点赞 2018-10-09 19:25:35
    C++ 基本数据类型和表达式 C++ 无条件转移控制 C++ 子程序间的数据传递 C++ main函数的返回值 C++ 标识符的作用域 C++ 变量的生存期 C++ 宏与内联函数 C++ 函数名重载 C++ 标准库 C++ 条件编译 C++ 枚举类型 C++ ...
  • python类与c++类对比

    千次阅读 2018-08-24 22:05:05
    写在前面 本文将从类的角度讨论python和c++在...先看c++类的一个简单的例子: class A { public: int i; void test() { std::cout &lt;&lt; i &lt;&lt; endl; } }; ..... A a; a.i = 1...
  • #c++类的实例

    千次阅读 2018-09-24 23:53:33
    #c++类的实例 这是一个c++类的简单实例 该实例实用类实现两个值的交换 虽然非常low 但对于理解类是很有帮助的 #include &lt;iostream&gt; #include &lt;string&gt; using namespace std; class tran...
  • C++类成员函数指针使用介绍

    万次阅读 多人点赞 2019-09-21 16:07:49
    在之前写过的博客中有介绍过函数指针和指针函数的区别和简单用法(文章在这里),当时的Demo非常简单,都是C语言的写法,但是当在C++中直接像C那样使用成员函数指针时就会报错:reference to non-static member ...
  • C++ 详解

    万次阅读 多人点赞 2017-02-09 09:13:12
    面对对象:面对将系统看成通过交互作用来完成特定功能的对象的集合。每个对象用自己的方法来管理数据。也就是说对象内部的代码能够操作对象内部...1. 的声明 class 名称 { public:  公有成员(外部接口) p
  • C++类和对象数组

    万次阅读 多人点赞 2018-05-14 23:47:15
    C++类和对象数组 【1】对象数组 1:对象数组的定义:类名 数组名[元素个数] Eg: student asa[10];//有10个元素的学生类对象数组 2:对象数组的访问形式:数组名[下标].成员名; Eg: asa[j].print(); 3:对象...
  • C++ Class Size (C++ 大小)

    千次阅读 2014-07-24 09:55:35
    C++ Class Size (C++ 大小)  2013-03-17 20:05:34| 分类: C++ | 标签:c++ class size 大小  |举报 |字号 订阅 最近在写B+Tree的时候突然发现对节点的大小没算准,导致不知道固定...
  • C++ 的设计规则

    千次阅读 2013-04-19 17:14:45
    类是C++ 语言的核心概念,要想写出高质量的C++代码,最重要的事情就是把类设计好,下面介绍一些C++类设计的基本规则。   1 命名  类名一般是名词,用大白话说就是类一般都是个“东西”,根据我的命名原则,业务...
  • C 调用 C++

    万次阅读 2018-09-14 15:57:44
    现在有个Person,其中成员函数分别用于获取 ...我们希望可以在 C 代码中调用 C++ 的方法。 person.h class Person { public: Person(std::string name, int age); ~Person() {} const char *GetName...
  • C++类(Class)的定义与实现

    万次阅读 多人点赞 2018-08-01 17:41:17
     在C++中, 用 "" 来描述 "对象", 所谓的"对象"是指现实世界中的一切事物。那么就可以看做是对相似事物的抽象, 找到这些不同事物间的共同点, 如自行车和摩托车, 首先他们都属于&...
  • C#调用C++类指南

    千次阅读 2017-06-29 10:58:33
    C#调用C++类比较麻烦,有两种方法,一种是原生C(Native C),即必须把C++的成员函数封装成C的全局函数(称为C bindings),然后再供C#调用。一种是托管C++(Managed C++)或者叫C++/CLI,可以识别C++的类和指针,...
  • C++ 模板与模板详解

    万次阅读 多人点赞 2018-03-24 17:22:58
    转自:https://www.cnblogs.com/cxq0017/p/6076856.html在C++的Template... 事实上class用于定义,在模板引入c++后,最初定义模板的方法为:template&lt;class T&gt;,这里class关键字表明T是一个类型,后...
  • C++接口

    千次阅读 2019-03-12 21:39:04
    C++中仅含有纯虚函数的成为接口,也就是没有数据成员 只有纯虚函数的成员函数 例如~ class Shape { public: virtual double calcArea()=0; virtual double calcPerimeter()=0; } 接口呢更多的是一种...
  • C++聚合

    千次阅读 2019-04-13 22:35:46
    聚合(aggregate class)使用户可以直接访问其成员,并且具有特殊的初始化语法。当一个满足以下条件时,我们说它是聚合的: 所有成员都是public 没有定义构造函数 没有内初始值 没有基类,也没有虚函数 我们...
  • c++静态实现

    万次阅读 2017-12-16 14:11:10
    c++静态 静态 静态实现 静态声明
  • Arduino编写C++类

    千次阅读 2016-10-22 13:45:41
    Arduino支持C/C++,理所当然的支持C++的class, 如果是经常要用到的,可以把它们封装成类库,这里不介绍; 对于自己编写的不常用到的,如何创建? 编写的方式有很多种,可以用C++的IDE来写,比如VS Studio、...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,149,772
精华内容 459,908
关键字:

c++类是什么

c++ 订阅