精华内容
下载资源
问答
  • 问题 #include <...string f1(const q &a) { return *a; } string f2(const string* &a) { return *a; } int main() { string s("hello"); cout << f1(&s) << en

    问题

    #include <iostream>
    #include <string>
    using namespace std;
    
    typedef string *q;
    string f1(const q &a)
    {
    	return *a;
    }
    
    string f2(const string* &a)
    {
    	return *a;
    }
    
    int main()
    {
    	string s("hello");
    	cout << f1(&s) << endl; //正确
    	cout << f2(&s) << endl; //报错,为什么?
    
    	system("pause");
    	return 0;
    }
    

    疑问点:将 f1 和 f2 的形参展开,二者的形式一样,但是传入相同参数时却一个正确一个错误。

    解答

    编译器对两者的解释不一样。
    先看 f1:这里的 q 表示 string* ,const q& 就是我们常见的常量引用,我们传入一个右值 &s ,由于可以将一个const引用绑定在一个右值上,所以没有任何问题。
    再看 f2:编译器对 const string* &a 的解释是首先 a 是一个引用,其次它是 const string* 类型的,而对于引用类型,实参与形参必须完全一致,所以函数要求的是 const string* 的引用,而我们传进去的是 string* ,所以会报错。
    (感谢冲哥对我的技术答疑)

    展开全文
  • void func(const char*&amp; str) { str++; } void func1(const char** str) { (*str)++; } int main() { const char* str="adas"; cout&lt;&lt;str&lt;&...
    #include <iostream>
    using namespace std;
    
    
    void func(const char*& str)
    {
    	str++;
    }
    
    void func1(const char** str)
    {
    	(*str)++;
    }
    
    int main()
    {
    	const char*  str="adas";
    	cout<<str<<endl;//adas
    	func(str);
    	cout<<str<<endl;//das
    	func1(&str);
    	cout<<str<<endl;//as
    	return 0;
    }
    #include <iostream>
    using namespace std;
    
    
    void func(char*& str)
    {
    	str++;
    
    }
    
    void func1(char** str)
    {
    	(*str)++;
    }
    
    int main()
    {
    	char* str="adas";
    	cout<<str<<endl;//adas
    	func(str);
    	cout<<str<<endl;//das
    	func1(&str);
    	cout<<str<<endl;//as
    	return 0;
    }

     

    展开全文
  • 函数形参const 引用

    2015-03-13 17:04:42
    这个函数里面的形参为什么这么修饰,一直没怎么搞明白,网上查了下,把弄清楚为什么要这么写 const sPlayerInfo& kPlayer const 表示常量不可修改,这应该好理解,表示传进去的参数kPlayer不能被修改。 但是为什么...

    最近看别人代码,CPlayerMgr::Updatepr_player(const sPlayerInfo& kPlayer)  

    这个函数里面的形参为什么这么修饰,一直没怎么搞明白,网上查了下,把弄清楚为什么要这么写


    const sPlayerInfo& kPlayer  const 表示常量不可修改,这应该好理解,表示传进去的参数kPlayer不能被修改。 但是为什么要加个引用呢

    const sPlayerInfo& kPlayer  与  const sPlayerInfo kPlayer有什么区别呢


    参考了别人的一篇文章

         1.非引用形参  

          void add1(int v1)       

          { 

              v1+=1;       

    }  

          这是最普通的形参方式,当函数被调用时,实参的副本初始化形参,函数并没有访问调用所传递的实参,因此v1+=1不会修改实参的值。对v1的操作只是修改了实参的一个副本。

       

        2. 引用形参  
          void swap(int &a,int &b)       

          { 
              int temp=a;           

             a=b;          

             b=temp;        

          }  
          引用形参直接关联到其所绑定的对象,而非这些对象的副本。 所以这种方法可以修改实参的值,而且更加直观。


    看到这里就明白 非引用形参的函数访问的其实是实参的副本,既然是副本,那当然是另外拷贝复制一份出来的,

    对于某些巨型类来说复制的速度非常慢, 而且也会有些类型在设计上拒绝复制(比如说cin和cout).
    所以人家用的是 const sPlayerInfo& kPlayer 而不是 const sPlayerInfo kPlayer 这样可以减少复制,提升效率,如果不考虑效率,其实两者的意义是一样的。
    但是, 对于int这样的小型的内置类型来说, 这丙种这几乎就真的没有差别了, 对于引用通常需要地址来传递, int类型占据的内存和地址一样或者更小(64位机器指针是64位大小)





    展开全文
  • 今天早上被小六打电话给吵醒了,呜呜,人家还没睡醒好不好。翻开书本,看到之前看到的一个东西,有两个问题:  -----------------------------------question--------------------...第一个问题是实参char *与形参con
     今天早上被小六打电话给吵醒了,呜呜,人家还没睡醒好不好。翻开书本,看到之前看到的一个东西,有两个问题:
            -----------------------------------question------------------------------------------------------------------------

    第一个问题是实参char *与形参const char* 为什么会相容
    第二个问题实参char **与形参const char **为什么会不相容。

            -----------------------------------question------------------------------------------------------------------------
    const是什么?
    const是一个C语言的关键字,它限定一个变量不允许被改变,产生静态作用。 
    const最有用之处就是用它来限定函数的形参,这样该函数将不会修改实参指针所指的数据,但其他的函数 却可能修改它。

    现在还有些晕乎。。。书本原文内容如下:
            ------------------------------------------------------------------------------分割线------------------------------------------------------------------------------- 
     
    一位销售工程师把下面这段代码作为测试例发给Sun的编译小组。
     
    1 foo(const char  **p)
    2
    3 main(int argc, char **argv)
    4 {
    5   foo(argv);
    6 }
     
    如果编译这段代码,编译器会发出一条警告信息:
    line 5: warning: argument is incompatible with prototype
    (第5行: 警告:参数与原型不匹配)。
     
    提交代码的工程师想知道为什么会产生这条警告信息,也想知道ANSIC标准的哪一部分讲述了这方面的内容。他认为,实参 char *s 与形参const char *p应该是相容的,标准库中所有的字符串处理函数都是这样的。那么,为什么实参char **argv 与形参const char **p实际上不相容呢?
     
    答案是肯定的,它们并不相容。要回答这个问题破费心机,如果研究一下获得这个答案的整个过程,会比仅仅知道结论更有意义。对这个问题的分析是由Sun的其中一位"语言律师"进行的,其过程如下:

     在ANSIC标准第6.3.2.2节中讲述约束条件的小节中有这么一句话:
     每个实参都应该具有自己的类型,这样它的值就可以赋值给与它所对应的形参类型的对象(该对象的类型不能含有限定符)。
     
     这就是说参数传递过程类似于赋值。
     
     所以,除非一个类型为char **的值可以赋值给一个const char **类型的对象,否则肯定会产生一条诊断信息。要想知道这个赋值是否合法,就请回顾标准中的有关简单赋值的部分,它位于6.3.16.1节,描述了下列约束条件:
     
     要使上述的赋值形式合法,必须满足下列条件之一:
     两个操作数都是指向有限定符或无限定符的相容类型的指针,左边指针所指向的类型必须具有右边指针所指向类型的全部限定符。
     

     正是这个条件,使得函数调用中实参char *能够与形参const char *匹配(在C标准库中,所有的字符串处理函数就是这样的)。它之所以合法,是因为在下面的代码中:
     
     char *cp;
     const char *ccp;
     ccp = cp;
     
     ~左操作数是一个指向const限定符的char的指针。
     ~右操作数是一个指向没有限定符的char的指针。
     ~char类型与char类型是相容的,左操作数所指向的类型具有右操作数所指向类型的限定符(无),再加上自身的限定符(const)。
     
     注意,反过来就不能进行赋值。如果不信,试试下面的代码:
     cp = cpp;
     
     标准第6.3.16.1节有没有说char **实参与const char **形参是相容的? 没有。
     标准第6.1.2.5节中讲述实例的部分声称:
     const float *类型并不是一个有限定符的类型---它的类型是"指向一个具有const限定符的float类型的指针",也就是说const限定符是修饰指针所指向的类型,而不是指针本身
     类似地,const char **也是一个没有限定符的指针类型,它的类型是"指向有const限定符的char类型的指针的指针"。
     
     由于char **和const char**都是没有限定符的指针类型,但它们所指向的类型不一样(前者指向char *,后者指向const char *),因此它们是不相容的。因此,类型为char**的实参与类型为const char**的形参是不相容的,违反了标准第6.3.2.2节所规定的约束条件,编译器必然会产生一条诊断信息。
    展开全文
  • 1 foo(const char **p) 2 3 main(int argc, char **argv) 4 { 5 foo(argv0); 6 } 编译此段代码,编译器会发出一条警告信息: Line 5: warning: argument is incompatible with orototype (第五行:警告:...
  • const对象只能调用const函数,自由对象优先调用非const函数。 函数后面加const 表示不能修改当前对象的数据。  2 mutable 关键字,让const函数 可以进行修改内部变量。 #include using namespace std...
  • #include <stdio.h> void foo(const char **p); int main() { char ch[2][20] = { "Hello world", "Hi"}; char** p = (char**)ch; foo(p); ret...
  • const形参和非const形参

    2019-10-03 09:45:22
    我们知道const形参是为了,是为了保证函数内部不会去修改形参。 而C++为了与C兼容,const形参与非const形参,在函数重载时,会被认为是同一个函数,所以就不会被编译器认为是重载,而是重复声明/定义了。 而对于...
  • 1,形参不确定类型时 可以使用decltype; 例如:返回s中出现的c的次数。 string::size_type findchar(const string &s ,char c,string::size_type &occurs){ auto ret =s.size(); occurs=0; for(...
  • 对于不该被修改的入参,应该用const修饰 const的作用就是限定一个变量为只读,使用const修饰一个变量,只能在开始声明时就赋值,后面就不能修改 //尝试运行以下代码,你会解决问题的。 //const修饰符,当你传入参数...
  • 传递非引用形参的数组类型的参数,其实如下 void func(int* a); void func(int a[]); void func(int a[10]); 是等价的,写成 void func(int* a);更加明确易读。 在void func(int a[10]); 里面数组大小10 会被...
  • void show_arry(const double* ar, int n); void mult_arr(double ar[], int n, double mult); int main() { double dip[SIZE] = { 20.0 , 17.66 , 8.2 , 15.3 , 22.22 }; printf("原始的dip数组数据:\n"); show...
  • const形参与非const形参

    2016-02-28 21:18:00
    在程序设计中我们会经常调用函数,调用函数就会涉及参数的问题,那么在形参列表中const形参与非const形参对传递过来的实参有什么要求呢? 先来看一个简单的例子: [java]view plain #include<iostream...
  • C++ Primer:形参const

    2020-03-16 14:27:08
    1. 形参本身是const 程序调用函数时会用实参来初始化形参,若形参本身是const,顶层const会被忽略。故不能通过判断形参本身是否是const来区分函数。 #include <iostream> using namespace std; class A { ...
  • const形参与数组形参

    2019-09-23 12:13:28
    const形参形参const时,要注意顶层constconst int ci = 42; //不能改变ci,const是顶层的 int i = ci; //正确,当拷贝ci时,忽略了它的顶层const int *const p = &i; //const是顶层的,不能给p...
  • C++函数中const形参与非const形参

    千次阅读 2015-09-11 21:50:33
    在程序设计中我们会经常调用函数,调用函数就会涉及参数的问题,那么在形参列表中const形参与非const形参对传递过来的实参有什么要求呢? 先来看一个简单的例子: #include #include using namespace std; ...
  • 一个拥有顶层constconst修饰变量自身)的形参无法和另一个没有顶层const形参区分开来: Record lookup(Phone); Record lookup(const Phone); //编译错,重复声明了Record lookup(Phone) 变量或常量的实参都...
  • /*在形参里加const有什么意义吗?是不是代表这个参数不能在函数里被修改?那为什么在下面的程序中,在print函数输出的还是修改后的对象呢?望大神们指点迷津!谢谢!*/ #include #include"string.h" using ...
  • Const形参与实参

    2020-06-15 17:01:07
    const的基础知识 ①没有用到指针 ②用到了指针 ③引用

空空如也

空空如也

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

形参const