精华内容
下载资源
问答
  • C++ 无参构造函数

    千次阅读 2020-05-28 08:59:20
    设计表示平面坐标位置的点类,可以修改和获取点的x、y坐标值,设置构造函数对点的数据成员进行初始化,并且能够用数组保存一系列的点。 #include<iostream> using namespace std; class Point { private: int...

    设计表示平面坐标位置的点类,可以修改和获取点的x、y坐标值,设置构造函数对点的数据成员进行初始化,并且能够用数组保存一系列的点。

    #include<iostream>
    using namespace std;
    class Point {
    private:
    	int x, y;
    public:
    	Point(int a, int b) { setPoint(a, b); }
    	int getx() { return x; }
    	int gety() { return y; }
    	Point() { x = 0; y = 0; }//显式定义无参构造函数
    	void setPoint(int a, int b) { x = a; y = b; }
    };
    Point p0;
    Point p1(1, 1);//调用构造函数Point(int,int)
    void main() {
    	static Point p2;
    	Point p3;
    	Point a[10];
    	Point* p4;
    	p4 = new Point;
    	p4->setPoint(8, 9);
    	cout << "p0:" << p0.getx() << "," << p0.gety() << endl;
    	cout << "p1:" << p1.getx() << "," << p1.gety() << endl;
    	cout << "p2:" << p2.getx() << "," << p2.gety() << endl;
    	cout << "p3:" << p3.getx() << "," << p3.gety() << endl;
    	cout << "p4:" << p4->getx() << "," << p4->gety() << endl;
    	cout << "a[0]:" << a[0].getx() << "," << a[0].gety() << endl;
    }
    
    展开全文
  • c++建立对象时要调用无参构造函数的情况有哪些,记得老师说有[]的,还有啥忘了,求帮忙解释一下,谢谢了。
  • #include <iostream.h> class A { public: A() { A(0); } A(int i) { m_data = i; } void Print() { cout<<m_data<<endl; } protected: ...
  • 构造函数是一个特殊的成员函数,名字和类名相同,创建类类型对象时由编译器... } 默认构造函数全缺省和无参之能出现一个,所以以下写法是错的: CLOCK(int newhour=10, int newminute=10, int newsecond=10); CLOCK();

     构造函数是一个特殊的成员函数,名字和类名相同,创建类类型对象时由编译器自动调用,虽然构造函数名称叫做构造,但是它的主要任务是初始化对象,而不是开空间创建对象,在对象的生命周期内只调用一次。如果用户没有编写构造函数,则编译器和自动提供一个无参数的构造函数,这个函数就叫默认构造函数。

    构造函数其特征如下:

     1 函数名与类型名相同。

    2 无返回值。

    3 对象实例化时编译器自动调用对应的构造函数。

    4构造函数可以重载。

    下面是一个构造函数的例子:

    #include<iostream>
    using namespace std;
    
    class CLOCK {
    
    public :
    	
    	CLOCK(int newhour, int newminute, int newsecond);
    
    	CLOCK();
    
    	void showtime();
    
    private:
    
    	int hour,minute,second;
    };
    
    CLOCK::CLOCK(int newhour, int newminute, int newsecond):hour(newhour),minute(newminute),second(newsecond){}
    
    CLOCK::CLOCK() : hour(0), minute(0), second(0) {}
    
    int main()
    {
    	CLOCK a();//a不是CLOCK类的实例化,a()是一个普通的无参的函数
    	
    	CLOCK b(20, 5, 2);
    
    	CLOCK c;
    	
    	b.showtime();
    
    	c.showtime();
    
    	return 0;
    
    }
    void CLOCK::showtime()
    {
    
    	cout << hour << ":" << minute << ":" << second << endl;
    
    }

     

    默认构造函数全缺省和无参之能出现一个,所以以下写法是错的:

    CLOCK(int newhour=10, int newminute=10, int newsecond=10);
    CLOCK();

     

    展开全文
  • C++关于默认构造函数和无参构造函数 默认构造函数 在不提供任何构造函数的情况下,编译器给出一个不带参数的,不包含代码的构造函数。 #include<iostream> using namespace std; class A { public: int val;...

    C++关于默认构造函数和无参构造函数

    默认构造函数

    在不提供任何构造函数的情况下,编译器给出一个不带参数的,不包含代码的构造函数。

    #include<iostream>
    using namespace std;
    
    class A
    {
    public:
        int val;
    };
    
    int main(){
        A a;    //这里调用的是默认构造函数
        cout<<a.val<<endl;
        return 0;
    }
    

    当已经提供了显式的构造函数,例如:

    #include<iostream>
    using namespace std;
    
    class A
    {
    public:
        int val;
        A(int n){
            val = n;
        }
    };
    
    int main(){
        A a;    //这里调用的是默认构造函数
        cout<<a.val<<endl;
        return 0;
    }
    

    此时编译就会出错,因为编译器认为已经提供了显式的构造函数就不会再提供默认构造函数了。这时需要添加一个无参构造函数,使得上述代码能够正确编译。

    #include<iostream>
    using namespace std;
    
    class A
    {
    public:
        int val;
        A(){}
        A(int n){
            val = n;
        }
    };
    
    int main(){
        A a;    //这里调用的是无参构造函数
        cout<<a.val<<endl;
        return 0;
    }
    
    展开全文
  • 文章目录函数的定义函数的的使用方法函数的返回值值传递指针传递引用传递C++引用作为函数返回值函数重载(Function Overloading)运算符重载(Operator Overloading)以成员函数的形式重载构造函数 函数的定义 函数...

    函数的定义

    函数就是一段封装好的,可以重复使用的代码,它使得我们的程序更加模块化,不需要编写大量重复的代码。

    函数可以提前保存起来,并给它起一个独一无二的名字,只要知道它的名字就能使用这段代码。
    函数还可以接收数据,并根据数据的不同做出不同的操作,最后再把处理结果反馈给我们。

    对于函数的定义来说,使用return语句可以向外提供该函数执行的一下结果;
    对于函数的调用者来说,是否可以使用函数中执行的一些操作结果,就在于函数是否使用return语句返回了对应的执行结果。

    函数的的使用方法

    从表面上看,函数在使用时必须带上括号,有必要的话还要传递参数,函数的执行结果也可以赋值给其它变量。
    例如,strcmp() 是一个用来比较字符串大小的函数,它的用法如下:

    #include <stdio.h>
    #include <string.h>
    int main(){
    char str1[] = “http://c.biancheng.net”;
    char str2[] = “http://www.baidu.com”;
    //比较两个字符串大小
    int result = strcmp(str1, str2);
    printf(“str1 - str2 = %d\n”, result);
    return 0;
    }

    str1 和 str2 是传递给 strcmp() 的参数,strcmp() 的处理结果赋值给了变量 result。

    函数的返回值

    既然函数可以处理数据,那就有必要将处理结果告诉我们,所以很多函数都有返回值(Return Value)。所谓返回值,就是函数的执行结果。例如:

    char str1[] = “C Language”;
    int len = strlen(str1);

    strlen() 的处理结果是字符串 str1 的长度,是一个整数,我们通过 len 变量来接收。

    函数返回值有固定的数据类型(int、char、float等),用来接收返回值的变量类型要一致。

    引用是 C++ 的新增内容,在实际开发中会经常使用;
    C++ 用的引用就如同C语言的指针一样重要,但它比指针更加方便和易用,有时候甚至是不可或缺的。

    同指针一样,引用能够减少数据的拷贝,提高数据的传递效率。

    我们知道,参数的传递本质上是一次赋值的过程,赋值就是对内存进行拷贝。
    所谓内存拷贝,是指将一块内存上的数据复制到另一块内存上。

    对于像 char、bool、int、float 等基本类型的数据,它们占用的内存往往只有几个字节,对它们进行内存拷贝非常快速。
    而数组、结构体、对象是一系列数据的集合,数据的数量没有限制,可能很少,也可能成千上万,对它们进行频繁的内存拷贝可能会消耗很多时间,拖慢程序的执行效率。

    C/C++ 禁止在函数调用时直接传递数组的内容,而是强制传递数组指针,而对于结构体和对象没有这种限制,调用函数时既可以传递指针,也可以直接传递内容;为了提高效率,我曾建议传递指针,这样做在大部分情况下并没有什么不妥。

    但是在 C++ 中,我们有了一种比指针更加便捷的传递聚合类型数据的方式,那就是引用(Reference)。

    在 C/C++ 中,我们将 char、int、float 等由语言本身支持的类型称为基本类型,将数组、结构体、类(对象)等由基本类型组合而成的类型称为聚合类型。

    引用(Reference)是 C++ 相对于C语言的又一个扩充。引用可以看做是数据的一个别名,通过这个别名和原来的名字都能够找到这份数据。引用类似于 Windows 中的快捷方式,一个可执行程序可以有多个快捷方式,通过这些快捷方式和可执行程序本身都能够运行程序;引用还类似于人的绰号(笔名),使用绰号(笔名)和本名都能表示一个人。

    引用的定义方式类似于指针,只是用&取代了*,语法格式为:type &name = data;
    type 是被引用的数据的类型,name 是引用的名称,data 是被引用的数据。
    引用必须在定义的同时初始化,并且以后也要从一而终,不能再引用其它数据,这有点类似于常量(const 变量)。

    凡是有引用类型的成员变量的类,不能有缺省构造函数。默认构造函数没有对引用成员提供默认的初始化机制,也因此造成引用未初始化的编译错误。

    构造函数的形参必须为引用类型,暂时还不知道该怎么解释,牵涉到引用的机制。

    C++函数的三种传递方式为:值传递、指针传递和引用传递

    值传递

    void fun(int x){
        x += 5;
        //修改的只是y在栈中copy x,
        // x只是y的一个副本,在内存中重新开辟的一块临时空间把y的值送给了x;
        // 这样也增加了程序运行的时间,降低了程序的效率。
    }
    
    void main(void)
    {
        int y = 0;
        fun(y);
        cout<<"y = \"<<y<<endl; //y = 0;
    }
    

    指针传递

    void fun(int *x){
        *x += 5; //修改的是指针x指向的内存单元值
    }
    void main(void){
        int y = 0;
        fun(&y);
        cout<<<<\"y = \"<<y<<endl; //y = 5;
    }
    

    引用传递

    void fun(int &x){
        x += 5; //修改的是x引用的对象值 &x = y;
    }
    void main(void){
        int y = 0;
        fun(y);
        cout<<<<\"y = \"<<y<<endl; //y = 5;
    }
    

    1.值传递:有一个形参向函数所属的栈拷贝数据的过程,如果值传递的对象是类对象或是大的结构体对象,将耗费一定的时间和空间。

    2.指针传递:同样有一个形参向函数所属的栈拷贝数据的过程,但拷贝的数据是一个固定为4字节的地址。

    3.引用传递:同样有上述的数据拷贝过程,但其是针对地址的,相当于为该数据所在的地址起了一个别名。
    注意,引用在定义时需要添加&,在使用时不能添加&,使用时添加&表示取地址。

    效率上讲,指针传递和引用传递比值传递效率高。一般主张使用引用传递,代码逻辑上更加紧凑、清晰。

    引用传递做函数参数”是C++的特性,C语言不支持。

    例如:数据结构带&与不带&

    带&的是引用型参数,它是地址传递,其实参会随着形参的改变而改变;
    不带&的参数是一般参数,是值传递,其实参不会随着形参的改变而改变。
    所以,结构改变,并且需要传回这种改变的要用引用型参数,否则用一般参数。
    GetElem(L,i)只是找到第i个元素的值,线性表的结构并未发生任何改变,所以参数L前面不用加&。
    ListInsert(&L,i,e)是在线性表L的第i个元素处插入一个数值为e的元素,线性表L的结构发生了改变,长度增加了,所以在L前必须加上&。如果不加,显示L时,新增元素就显示不出来,显示L的长度,也仍然是增加以前的值,比实际长度少1.

    C++引用作为函数返回值

    引用除了可以作为函数形参,还可以作为函数返回值,请看下面的例子:

        #include <iostream>
        
        using namespace std;
        
        int &plus10(int &r) {
            r += 10;
            return r;
        }
        
        int main() {
            int num1 = 10;
            int num2 = plus10(num1);
            cout << num1 << " " << num2 << endl;
            return 0;
        }
    
    运行结果:
    20 20
    

    在将引用作为函数返回值时应该注意一个小问题,就是不能返回局部数据(例如局部变量、局部对象、局部数组等)的引用,
    因为当函数调用完成后局部数据就会被销毁,有可能在下次使用时数据就不存在了,C++ 编译器检测到该行为时也会给出警告。

    更改上面的例子,让 plus10() 返回一个局部数据的引用:

     #include <iostream>
        using namespace std;
        int &plus10(int &r) {
            int m = r + 10;
            return m;  //返回局部数据的引用
        }
        int main() {
            int num1 = 10;
            int num2 = plus10(num1);
            cout << num2 << endl;
            int &num3 = plus10(num1);
            int &num4 = plus10(num3);
            cout << num3 << " " << num4 << endl;
            return 0;
        }
    

    在 GCC 下的运行结果:

    20
    30 30

    plus10() 返回一个对局部变量 m 的引用,这是导致运行结果非常怪异的根源,因为函数是在栈上运行的,并且运行结束后会放弃对所有局部数据的管理权,后面的函数调用会覆盖前面函数的局部数据。

    函数重载(Function Overloading)

    所谓重载,就是赋予新的含义。函数重载(Function Overloading)可以让一个函数名有多种功能,在不同情况下进行不同的操作。运算符重载(Operator Overloading)也是一个道理,同一个运算符可以有不同的功能。

    实际上,我们已经在不知不觉中使用了运算符重载。例如,+号可以对不同类型(int、float 等)的数据进行加法操作;<<既是位移运算符,又可以配合 cout 向控制台输出数据。C++ 本身已经对这些运算符进行了重载。

    运算符重载(Operator Overloading)

    运算符重载其实就是定义一个函数,在函数体内实现想要的功能,当用到该运算符时,编译器会自动调用这个函数。也就是说,运算符重载是通过函数实现的,它本质上是函数重载。

    运算符重载的格式为:
    返回值类型 operator 运算符名称 (形参表列){
    //TODO:
    }
    operator是关键字,专门用于定义重载运算符的函数。我们可以将operator 运算符名称这一部分看做函数名。

    运算符重载函数除了函数名有特定的格式,其它地方和普通函数并没有区别。

    以成员函数的形式重载

    Complex & operator+=(const Complex &c);
    Complex & operator-=(const Complex &c);
    Complex & operator*=(const Complex &c);
    Complex & operator/=(const Complex &c);
    

    构造函数

    构造函数的作用是在创建类的对象时进行类对象初始化的。

    在 C++ 中,每个类都有且必须有构造函数。如果用户没有自行编写构造函数,则 C++ 自动提供一个无参数的构造函数,称为默认构造函数。这个默认构造函数不做任何初始化工作。一旦用户编写了构造函数,则这个无参数的默认构造函数就消失了。如果用户还希望能有一个无参数的构造函数,必须自行编写。

    构造函数也是一种函数, 所以在定义时可以将其定义为有参数和无参数两种,如下所示:

    
    using namespace std;
    //类的构造函数的分类:无参构造函数。有参构造函数。拷贝构造函数
    class Test2
    {
    public:
    	Test2()//无参构造函数
    	{
    		m_a = 0;
    		m_b = 0;
    		cout << "无参构造函数" << endl;
    	}
    	Test2(int a)
    	{
    		m_a = a;
    		m_b = 0;
    	}
    	Test2(int a, int b)
    	{
    		m_a = a; m_b = b;
    		cout << "有参构造函数"<< endl;
    	}
    	//copy构造函数
    	Test2(const Test2& obj)
    	{
    		cout << "我也是构造函数"<< endl;
    	}
    public:
    	void print()
    	{
    		cout << "普通成员函数"<< endl;
    	}
    private:
    	int m_a;
    	char m_b;
    };
    

    拷贝构造函数是一种特殊的构造函数,它在创建对象时,是使用同一类中之前创建的对象来初始化新创建的对象。拷贝构造函数通常用于:

    通过使用另一个同类型的对象来初始化新创建的对象。
    复制对象把它作为参数传递给函数。
    复制对象,并从函数返回这个对象。
    如果在类中没有定义拷贝构造函数,编译器会自行定义一个。如果类带有指针变量,并有动态内存分配,则它必须有一个拷贝构造函数。拷贝构造函数的最常见形式如下:

    展开全文
  • 1.c++编译器会自动调用构造函数//构造函数(与类名相同) //析构函数:没有参数也没有任何返回类型,被自动调用 ...//无参构造函数 ~Test();//析构函数:先创建的对象后释放 void print() { cout &lt;&lt;...
  • #include <iostream> using namespace std; struct Foo { Foo() {} Foo(int) {} void fun() {} }; int main() { Foo a(10); a.fun(); Foo b(); b.fun(); return 0;...
  • C++参构造函数——带有默认值 在一个类中 ,如果程序员没有写,任何一个构造函数,则编译器将为该类提供一个默认的构造函数,如果程序员对类的构造函数进行了重载,则编译器将不提供默构造函数,这里需要手动书写...
  • //无参构造函数 A() { cout << "调用无参构造函数" << endl; } ~A() { cout << "调用析构函数" << endl; } }; void obj() { //定义类A的对象,并调用无参构造函数 A a; } int ...
  • c++中调用无参数构造函数.............. #include <... //无参构造函数 A() { cout << "调用无参构造函数" << endl; } ~A() { cout << "调用析构函数" << ...
  • 1 struct Exmpl ... 3 //无参默认构造函数 4 Exmpl(){cout<<"Exmpl()"<<endl;} 5 //拷贝构造函数 6 Exmpl(const Exmpl&a){cout<<"Exmpl(const Exmpla&)"<<endl;} ...
  • c++无参构造函数的作用: 该类对象被创建时,编译系统为对象分配内存空间,并自动调用该构造函数**->由构造函数完成成员的初始化**工作。 故:**构造函数的作用:**初始化对象的数据成员。 举例: class ...
  • //只有一个显式的无参构造函数 class B{ public: B(){} }; //只有一个显式的拷贝构造函数 class C{ public: C(const C &c){} }; 这个是主函数: int main(){ //通过看编译的信息可以知道,A类编译是通过...
  • C++深度解析 对象的构造(下)---无参构造函数,拷贝构造函数,深拷贝,浅拷贝(18)       特殊的构造函数 无参构造函数 当类中没有定义构造函数时,编译器默认提供一个无参构造函数,并且其函数体为空。 ...
  • 无参参构造函数

    千次阅读 2019-08-20 09:47:35
    C++无参和有参函数的调用
  • 构造函数C++中用于初始化对象状态的特殊函数 构造函数在对象创建时自动被调用(默认调用),隐身调用 构造函数和普通成员函数一样尊重重载规则 拷贝构造函数是对象正确初始化的重要保证 必要时,必须手工编写...
  • 文章目录构造函数初始化构造函数初始化列表拷贝构造函数析构函数 ...构造函数分为无参构造函数和有参构造函数,无参构造函数就是默认构造函数,有参构造函数如果参数均赋有默认值则是默认构造函数,因此默认构造函...
  • c++中的构造函数

    2019-05-05 13:43:15
    c++中有两类特殊的构造函数,分别是:无参构造函数和拷贝构造函数。 无参构造函数 首先无参构造函数,它是当你的程序中没有定义任何的构造函数时,编译器会默认的给你加上一个无参构造函数(这是因为定义对象一定会...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,225
精华内容 490
关键字:

c++无参构造函数

c++ 订阅