C++11/14/17特性学习（1）
Chapter 1, Deducing Type
Item 1: Template type deduction
一些基础知识：
关于左值和右值的一些解释：
一般来说，能找到地址的、具有名字的、位于等号左侧的都是左值，否则是右值。右值一般是匿名的，或者函数返回值也是右值。
一般情景：
int a=1,b=2,c=3;
int* d=&(b+c);
int& d=(b+c);
const int& d=(b+c);
template&typename T&
T value=ReturnValue();
const T& r_value=ReturnValue();
使用右值的时候，右值必须有一个引用才行。否则只能通过把右值的值复制给左值的方式保留右值的内容，复制完毕后，右值立刻被销毁。不能通过指针指向右值，因为右值等效理解为没有地址。
关于const的使用
和完全等效。
int* const
先看const再看* ，是p是一个常量类型的指针，不能修改这个指针的指向，但是这个指针所指向的地址上存储的值可以修改。
const int *p;
先看*再看const，定义一个指针指向一个常量，不能通过指针来修改这个指针指向的值。
template&typename T&
void f(ParamType param);
Case 1: ParamType 是引用或者指针, 但不是右值
模板作为函数参数时，会忽略实际函数参数中的引用成分，但是如果原来模板中用引用参数，那么模板的引用起作用。
expr的类型会优先覆盖掉ParamType的类型，以实际引用的为准。
如果模板中出现引用，那么不管实际参数中是否有引用，都作为引用看待。
为代码举例:
template&class T&
void f(T& param);
// param is reference
// x is an int
const int cx=x;
// cx is an const int
const int& rx=x;
// rx is an reference to x as a const int
// T is int, param is int&
// cx is const int, param is const int&
// T is const int, param is const int&
#include &iostream&
using namespace std;
template&typename T&
void f(T x){
template&typename T&
void f1(T& x){
int main() {
const int cx=x;
int& rx=x;
cout&&"x="&&x&&", cx="&&cx&&", rx="&&rx&&
cout&&"x="&&x&&", cx="&&cx&&", rx="&&rx&&
template&typename T&
void f(const T& param);
// param is a ref-to-const
const int cx=x;
const int& rx=x;
// T is int, param is type of const int&
// T is int, param is type of const int&
// T is int, param is type of const int&
指针类型的伪代码:
template&typename T&
void f(T* param);
// param is now a pointer
// as before
const int* px=&x;
// px is a ptr to x as a const int
// T is int, param is int*
// T is const int, param is const int*
Case2 ParamType是右值
函数声明形式：
template&typename T&
void f(T&& param);
const int cx=x;
const int& rx=x;
总结：如果传入参数不是左值，那么按照Case1的情景处理，区别在于非引用类型转换成引用类型，引用类型还是引用。如果传入右值，则T变成传入的类型，参数的位置变成右引用。
Case3: ParaTYpe不是指针和引用
如果expr是引用，忽略引用。
template&typename T&
void f(T param);
const int cx=x;
const int& rx=x;
数组类型按值传递
按值传递的时候，推断类型会把数组类型等效成指针类型。
const char name[]="J. P. Briggers";
const char* ptrToName=
template&typename T&
void f(T param);
数组类型按引用传递
数组类型按引用传递的时候，会把数组类型推断成实际的数组类型
const char name[]="J. P. Briggers";
const char* ptrToName=
template&typename T&
void f(T& param);
#include&iostream&
using namespace std;
template&typename T&
int f(T param){
return sizeof(param);
template&typename T&
int f1(T& param){
return sizeof(param);
int main(){
const char name[]="Hello World!";
const char* ptrToName=
a=f(name);
b=f(ptrToName);
cout&&a&&" "&&b&&
a=f1(name);
b=f1(ptrToName);
cout&&a&&" "&&b&&
volatile的简介： volatile是给编译器的指示来说明对它所修饰的对象不应该执行优化。volatile的作用就是用来进行多线程编程。在单线程中那就是只能起到限制编译器优化的作用。在单线程编程的时候，除了不优化之外，几乎没有其他的作用。
在参数推断的过程中，原来参数的引用总是总是被当作没有引用看待。
参数是按值传递的模板的时候，const和volatile 总是被当作non-const和non-volatile看待，比如说
f(T param)的时候，param的引用会被忽略。
参数推断的时候，只有模板引用(f(T& param))形式的数组名被当作非指针看待，其余的数组名一律视为指针。
Item 2: Understand auto type deduction
auto的引用分为3种情况：
推断类型是引用或者指针，但不是右值引用
推断类型是右值引用
推断类型不是指针也不是引用。
const auto& rx =
此时，auto就是推断的x的实际类型。
const auto* rx =
auto推断的是x的实际类型。
const int cx =
const int& rx =
auto&& uref1 =
auto&& uref2 =
auto&& uref3 = 27;
关于数组的一些补充：
const char str[] = "Hello World !";
auto arr1 = str;
auto& arr2 = str;
关于函数的一些补充：
void fun(int,double);
auto模板推断内部的类型必须一致！
auto x = {1, 2, 3.0};
auto x = {1, 2, 3};
区别说明：
auto可以推断列表，而template不能推断列表类型。
#include &iostream&
using namespace std;
struct Node {
template&typename T&
void f(T param) {}
template&typename T&
void f1(std::initializer_list&T& initlist) {
cout && sizeof(initlist) && " ";
int main() {
auto x = {1, 2, 3};
cout && sizeof(x) && " ";
f1({1, 2, 3});
cout && sizeof(std::initializer_list&int&) && " ";
模板的类型大小永远是16字节，与推断的类型无关。
auto类型基本与template类型推断一样，唯一的区别在于auto假设初始化是一个std::initial_list，但是template没有这个限制。
auto推断列表类型的时候，不管列表的数据是什么，永远是占用16个字节
auto推断列表的时候，列表内部的数据类型必须一致了。
函数返回auto或者lambda的时候，参数是一个隐藏的模板类型，而不是auto类型。
补充内容：
C++复制（拷贝）构造函数：
一般情况下，采用传入参数的方式。
Ex(int a,int b){_a=a;_b=b;}
int _a,_b;
int main(){
Ex ex(1,2);
借助另一个对象初始化
class Ex{};
// 上一个例子的Ex
Ex A(10,20);
对第4行来说，当传递给对象一个对象作为参数时，编译器会自动为每一个对象构造一个拷贝构造函数，但仅仅是使用传入的类的数值初始化成员。
class Ex{};
Ex::Ex(const Ex& ex){
上述使用默认构造函数的方法仅仅是一种浅拷贝。这种方式不会处理静态数据成员；同时，也仅仅是对数据成员进行一个赋值。如果存在动态的数据对象的时候，这种方式有很大的隐患。
#include &iostream&
using namespace std;
Ex(int n=10){
p=new int[n];
~Ex(){delete[]}
int main() {
Ex ex1(20);
Ex ex2(ex1);
if(ex1.p==ex2.p){
cout&&"same address"&&
cout&&"different address"&&
这种方式的默认构造函数，会造成ex2.p和ex1.p指向同一个内存地址块，而不是开辟一块新的内存地址。这就是一种浅拷贝。
深拷贝的方式：自己重写默认拷贝函数，对于上边的例子，重写为：
#include &iostream&
using namespace std;
Ex(int n=10){
p=new int[n];
Ex(const Ex& ex){
p=new int[100];
~Ex(){delete[]}
int main() {
Ex ex1(20);
Ex ex2(ex1);
if(ex1.p==ex2.p){
cout&&"same address"&&
cout&&"different address"&&
在这个例子中，注意重写复制构造函数的时候，需要至少一个默认构造函数，否则会有被复制的对象没有复制的对象的错误。
防止使用默认构造函数的方式：把默认构造函数在私有范围内声明一下就行。私有成员不能被调用。这种情况主要用于类中有动态成员的情景。比如下面的代码：
#include &iostream&
using namespace std;
Ex(int n=10){
p=new int[n];
~Ex(){delete[]}
Ex(const Ex& );
int main() {
Ex ex1(20);
Ex ex2(ex1);
Ex ex3=ex1;
拷贝构造函数不能处理静态成员，静态成员要在运行时候初始化。在调用时，不对静态成员做处理。
#include &iostream&
using namespace std;
static int
int Ex::n=0;
int main() {
Ex ex2(ex1);
Ex ex3(ex1);
cout&&Ex::n&&
C++初始化的方式：
C++11及以后的版本，为了统一初始化方式，提出了列表初始化的概念。
C++98/03中，只能对普通数组和POD(plain old data)进行列表初始化。比如：
int arr[]={1,2,3,4,5};
A a1{1,2};
int b{10};
C++11及以后的版本中，初始化列表可以用于任何对象，以类为例：
#include &iostream&
using namespace std;
class Ex {
Ex(int t = 0) {
Ex(const Ex& ex);
int main() {
Ex ex1(10);
Ex ex2{20};
Ex ex3 = {30};
cout && ex1.n && " " && ex2.n && " " && ex3.n &&
在动态结构中：
int* a = new int[3] {1, 2, 3};
int b[] = {4, 5, 6};
int* c = new int{7};
可以使用列表进行构造的条件：必须是一个聚合体，聚合体定义：
无用户自定义构造函数
无私有或者受保护的非静态数据成员。静态数据成员的初始化是不能通过初始化列表来完成初始化的，它的初始化还是遵循以往的静态成员的额初始化方式私有或者保护成员无法直接访问 。
无基类和虚函数
无{}和=直接初始化的非静态数据成员
如果不是聚合体，也可以构造，但是构造的结果会发生变化。
std::initial_list的介绍：
在C++11中，对于任意的STL容易都与和为显示指定长度的数组一样的初始化能力。
int arr[] = { 1, 2, 3, 4, 5 };
std::map & int, int & map_t { { 1, 2 }, { 3, 4 }, { 5, 6 }, { 7, 8 } };
std::list&std::string& list_str{ "hello", "world", "china" };
std::vector&double& vec_d { 0.0,0.1,0.2,0.3,0.4,0.5};
std::initialzer_list可以接受任意长度的同类型的数据也就是接受可变长参数{…}
#include &iostream&
using namespace std;
struct Ex {
Ex(std::initializer_list&int&list) {
auto it = list.begin();
x = *it++;
y = *it++;
z = *it++;
struct Ex2 {
Ex2(int a, int b, int c): x(a), y(b), z(c) {}
int main() {
Ex ex1{1, 2, 3};
cout && ex1.x && " " && ex1.y && " " && ex1.z &&
Ex2 ex2{1, 2, 3};
cout && ex2.x && " " && ex2.y && " " && ex2.z &&
Ex ex3(std::initializer_list&int& {4, 5, 6});
cout && ex3.x && " " && ex3.y && " " && ex3.z &&
Item 3: Understand decltype
decltype告诉我们我们给出的名字或者表达式的类型。
class Widget {};
const int i = 1;
bool f(const Widget& w);
struct Point {
if(f(w)) {}
vector&int&
if(v[0] == 0)
decltype类型推断，可以理解成声明后延。C++11中，decltype用于声明函数返回值以来与参数本身类型的函数模板。但是，C++中，利用[]返回容器引用的时候，还是需要依赖容器的类型，decltype的使用极大的方便了这样的表达。
template&typename Container, typename Index&
auto Test(Container& c, Index i)-&decltype(c[i]) {
return c[i];
decltype(auto) Test1(Container& c, Index i) {
return c[i];
int main() {
在上述的代码Test函数中，c是一个Container容器，我们的目的是返回c的下标为i的索引，但是我们无法得知用户实际使用容器的存放的数据类型，很难使用传统的方式返回值，因此在这里，直接使用auto结合decltype的方式。
补充说明一点：在C++11/14中，对于绝大多数容器来说，[ ]的返回一个T&，是返回的引用类型。
#include &iostream&
#include &vector&
using namespace std;
template&typename Container, typename Index&
auto f(Container& c, Index i)-&decltype(c[i]) {
return c[i];
template&typename Container, typename Index&
auto f_wrong(Container& c, Index i) {
return c[i];
int f_test(int* a, int i) {
return a[i];
int main() {
vector&int&v{1, 2, 3};
int a[] {1, 2, 3};
f(v, 0) += 1;
cout && v[0] &&
f(a, 0) += 1;
cout && a[0] &&
f_wrong(v,0) += 1;
f_test(a, 0) += 1;
decltype不仅仅是在函数返回值的时候使用有效，也可以在初始化声明变量或者表达式的时候
在非函数参数中：
class Ex {};
const Ex& ex1 =
auto myEx1 = ex1;
decltype(auto) myEx2 = ex1;
一些其他的说明：
decltype((x))返回x的引用。
decltype(auto)f1() {
int x = 0;
decltype(auto)f2() {
int x = 0;
return (x);
int main() {
decltype基本都是用于不被更改的变量或者表达式上。
对于返回T类型的左值表达式来说，decltype总是推断成T&类型
C++14支持decltype(auto)， 使用一般的decltype推断规则。
Item 4: Know how to view deduced types
一般适合简单的数据类型。IDE无法推断过于复杂或者运行时推断的类型。
编译器诊断：
编译器报错的时候显示。
使用库函数
库函数typeid().name()
#include &iostream&
using namespace std;
int main() {
struct Node {
std::cout && typeid(N).name() && std::
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：49次
排名：千里之外c++判断题， 在形如x=expression的赋值语句中，x的值总是等于右端表达式expr_百度知道
c++判断题， 在形如x=expression的赋值语句中，x的值总是等于右端表达式expr
c++判断题，在形如x=expression的赋值语句中，x的值总是等于右端表达式expression的值，这句话是错的，能举个反例吗
我有更好的答案
&&&nbsp.num&+&rhs)&&&&:num(i)&{}&&&&&Fuck&1;&nbsp:&nbsp:&&&nbspclass&&i&=&Fuck{&&Fuck(int&&&//=号可以被重载&&&&{&operator=(const&Fuck&&0)&num&=&//你想变成就是啥&&&&&&&&return&*&&&&}private
采纳率：28%
为您推荐：
其他类似问题
换一换
回答问题，赢新手礼包
个人、企业类
违法有害信息,请在下方选择后提交
色情、暴力
我们会通过消息、邮箱等方式尽快将举报结果通知您。C++中赋值语句和赋值表达式的区别_百度知道
C++中赋值语句和赋值表达式的区别
如题：C++中赋值语句和赋值表达式的区别我要详细的答案，不要从百度上复制，那上面不详细，我要的是详细区别与使用区别如：
的区别，各在什么情况下用谢了~
我有更好的答案
比如：int i=5;int j=7;(j=6)=(i=8);/)=(i=8);/正确，j会变成8(j=6，编译不通过表达式的结果为右值时;;//错误，可以用在所有能放置左值的地方，但是赋值语句则不可以。我们通常遇到的赋值表达式得到的都是一个左值赋值表达式是可以嵌套的，你只需要记住赋值表达式相当于一个值，但是赋值语句是一个执行语句，并不能当成一个值进行嵌套
采纳率：65%
来自团队：
听不明白 问题。。。 能再具体说说嘛，不然还真不好回答
你这问题比较笼统 我理解不透彻
为您推荐：
其他类似问题
赋值语句的相关知识
换一换
回答问题，赢新手礼包
个人、企业类
违法有害信息,请在下方选择后提交
色情、暴力
我们会通过消息、邮箱等方式尽快将举报结果通知您。C语言参数中表达式计算顺序问题_百度知道
C语言参数中表达式计算顺序问题
C语言函数参数是从右向左传递的。如果参数中含自增（自减）表达式，那么是先传参还是先运算呢？
#include &stdio.h&
#include &stdlib.h&
int argtest(int, int);
int main()
int i = 1;
argtest(i, i++);
argtest(i++, i+...
C语言的运算符主要用于构成表达式，同一个符号在不同的表达式中，其作用并不一致。下面按计算的优先顺序，分别说明不同作用的表达式。需要特别指出，在C语言标准中，并没有结合性的说法。 相同优先级运算符，从左至右依次运算。注意后缀运算优先级高于前缀。因此++i++应解释为++(i++)。而与或非的运算优先级都不一样，因此a && b || b && c解释为(a && b) || (b && c)合理使用优先级可以极大简化表达式。基本表达式 1级基本表达式（Primary expressions），主要是用于运算符之间，做为运算数。标识，常量，字符串文字量，优先级提升表达式最优先执行。优先级提升表达式是指圆括号包围的表达式，如“( expression )”后缀表达式 2极postfix-expression [ expression ]，数组下标运算。postfix-expression ( argument-expression-list)，函数调用，括号内的参数可选。postfix-expression . identifier，成员访问，postfix-expression -& identifier，成员访问，-&号之前应为指针。postfix-expression ++，后缀自增postfix-expression --，后缀自减( type-name ) { initializer-list }( type-name ) { initializer-list , } 复合初始化，C99后新增。例如int* a = (int[]) { 1, 2, 3 };//等价于 int unamed[] = {1, 2, 3}; //unamed表示一个不可见的变量名。int* a = 单目/一元运算 3级++ unary-expression 前缀自增-- unary-expression 前缀自减unary-operator cast-expression 单目转型表式式， 包括 取地址& ，提领 * ， 正号+ ，负号- 位反~ 逻辑否!。sizeof unary-expression 求类型长度，对表达式求类型长度sizeof ( type-name ) 求类型长度强制类型表达式 4级( type-name ) cast-expression，强制表达式成为type-name指定的类型。乘法表达式 5级“ * ” 乘法运算符；“ / ”除法运算符；“ % ” 取余运算符。加法运算符 6级“ + ”加法运算符；“ - ”减法运算符。移位运算符 7级&& 左移运算符；&& 右移运算符。关系运算符 8级&、&=、&、&=关系运算符。相等运算符 9级“ == ”等于运算符；“ != ”不等于运算符。位与运算符 10级“ & ”按位与运算符位异或运算符 11级“ ∧ ”按位异或运算符（Bitwise exclusive OR operator）。位或运算符 12 级“ | ”按位或运算符（Bitwise inclusive OR operator）。　　逻辑与运算符 13级“&&”逻辑与运算符。逻辑或运算符 14 级“ || ”逻辑或运算符。三元条件运算符 15级? :条件运算符。赋值运算符 16 级=、 +=、 -=、 *=、 /=、 %=、 &=、 ^=、 |=、 &&=、 &&=赋值运算符。逗号运算符 17级“，”逗号运算符。[pre]C 语言中，逗号（,）也可以是运算符，称为逗号运算符（Comma Operator）。逗号运算符可以把两个以上（包含两个）的表达式连接成一个表达式，称为逗号表达式。其一般形式为：　　子表达式1, 子表达式2, ..., 子表达式n　　例如：　　a + b, c = b, c++　　逗号运算符的优先级是所有运算符中级别最低的，通常配合 for 循环使用。逗号表达式最右边的子表达式的值即为逗号表达式的值。上例中，c++ 的值（c 自增之前的值）即为该表达式的值。　　逗号运算符保证左边的子表达式运算结束后才进行右边的子表达式的运算。也就是说，逗号运算符是一个序列点，其左边所有副作用都结束后，才对其右边的子表达式进行运算。因此，上例中，c 得到 b 的值后，才进行自增运算。优先级：C语言中，运算符的运算优先级共分为15 级。1 级最高，15 级最低。 在表达式中，优先级较高的先于优先级较低的进行运算。而在一个运算量两侧的运算符 优先级相同时，则按运算符的结合性所规定的结合方向处理。结合性：C语言中各运算符的结合性分为两种，即左结合性(自左至右)和右结合性(自右至左)。例如算术运算符的结合性是自左至右，即先左后右。如有表达式x-y+z 则y 应先与“-”号结合，执行x-y 运算，然后再执行+z 的运算。这种自左至右的结合 方向就称为“左结合性”。而自右至左的结合方向称为“右结合性”。最典型的右结合 性运算符是赋值运算符。如x=y=z,由于“=”的右结合性，应先执行y=z 再执行x=(y=z)运算。C语言运算符中有不少为右结合性，应注意区别，以避免理解错误。优先级从上到下依次递减，最上面具有最高的优先级，逗号操作符具有最低的优先级。所有的优先级中，只有三个优先级是从右至左结合的，它们是单目运算符、条件运算符、赋值运算符。其它的都是从左至右结合。具有最高优先级的其实并不算是真正的运算符，它们算是一类特殊的操作。()是与函数相关，[]与数组相关，而－&及.是取结构成员。其次是单目运算符，所有的单目运算符具有相同的优先级，因此在我认为的 真正的运算符中它们具有最高的优先级，又由于它们都是从右至左结合的，因此*p++与*(p++)等效是毫无疑问的。另外在C语言里，没有前置后置之分，因为++ -- 是右结合所以右侧优先运算，表现为 &操作数后置优先级比较高& 的假象，前置和后置的区分是因为运算符重载而后加入C++的接下来是算术运算符，*、/、%的优先级当然比+、－高了。移位运算符紧随其后。其次的关系运算符中，& &= & &=要比 == !=高一个级别，不大好理解。所有的逻辑操作符都具有不同的优先级（单目运算符除外，！和~）逻辑位操作符的&与&比&或&高，而&异或&则在它们之间。跟在其后的&&比||高。接下来的是条件运算符，赋值运算符及逗号运算符。在C语言中，只有4个运算符规定了运算方向，它们是&&、| |、条件运算符及赋值运算符。&&、| |都是先计算左边表达式的值，当左边表达式的值能确定整个表达式的值时，就不再计算右边表达式的值。如 a = 0 && &&运算符的左边位0，则右边表达式b就不再判断。在条件运算符中。如a?b:c；先判断a的值，再根据a的值对b或c之中的一个进行求值。赋值表达式则规定先对右边的表达式求值，因此使 a = b = c = 6;成为可能。口诀注释优先级等级口诀圆方括号、箭头一句号， 自增自减非反负、针强地址长度，乘除，加减，再移位，小等大等、等等不等，八位与，七位异，六位或，五与，四或，三疑，二赋，一真逗。其中“，”号为一个等级分段。优先级等级注释“圆方括号、箭头一句号”指的是第15级的运算符。其中圆方括号很明显“（）、[]”，箭头 指的是指向结构体成员运算符“-&”，句号 指的是结构体成员运算符“.” ；“自增自减非反负、针强地址长度”指的是第14级的运算符。其中 非 指的是逻辑运算符“!”，反 指的是按位取反运算符“~”，负 指的是负号运算符“－”，针 指的是指针运算符“*”，强 指的是强制类型转换运算符，地址 指的是地址运算符“&”，长度 指的是长度运算符“sizeof ”；“乘除，加减，再移位”移位指的是左移运算符“&&”和右移运算符“&&”，其中除法还包括了 取余运算符“%”；“小等大等、等等不等” 指的是第10级到第9级的运算符：&、&=、&和&=，等等指的是等于运算符==，不等指的是不等于运算符!=“八位与，七位异，六位或”其中 八位与 指的是第8级的 按位与 运算符“&”，七位异 指的是第7级的按位异或运算符“^”，六位或 指的是第6级的按位或运算符“|”；“五与，四或”指的是第5级、第4级的逻辑与运算符“&&”和逻辑或运算符“||”；“三疑，二赋，一真逗”指的是第3级到第1级的运算符。其中，三疑指的是条件运算符“？：” （三有双重含义：即指优先级别是三，它的运算符类型也是三目，疑也取“?”之意），二赋 指的是赋值运算符=、+=、-=、*=、/=、%=、&&=、&&=、&=、^=和|= ，一真逗 指的是第1级的“，”运算符，真字只是为了语句需要罢了。由于C语言的运算符优先级与C++的不完全一样(主要是增加了几个运算符)，所以这个口诀不能完全实用于C++.但是应该能够兼容，大家可以比较一下他们的区别应该就能够很快掌握C++的优先级的！应用举例1、赋值运算符：a=5;a=b=0;第一个赋值语句把5赋给变量a；第二个赋值语句的意思是把0同时赋值给两个变量。这是因为赋值语句是从右向左运算的，也就是说从右端开始计算，先b=0，然后a=b。2、复合赋值运算符：a=1;a+=3;上面第二个赋值语句等价于a=a+3;即a=4。3、算术运算符：Area=Height*Wnum=num1+num2/num3-num4;第一个赋值语句Height和Width相乘结果赋给变量Area；第二个赋值语句先完成num2与num3的整除运算，然后与num1相加，再减去num4，结果赋给num。运算符运算顺序先算乘除再算加减。单目正和单目负最先运算。4、逻辑运算符：a=1,b=1;a||b-1;因为a=1为真值，所以不管b-1是不是真值，总的表达式一定为真值，这时后面的表达式就不会再计算了。5、关系运算符：if(a&0)...如果a&0，则执行if语句中的内容，否则退出。6、条件运算符：a=(b&0)?b:-b;当b&0时，a=b；当b不大于0时，a=-b；其实上面的意思就是把b的绝对值赋值给a。7、逗号运算符：b=2,c=7,d=5;a=(++b,c--,d+3);有三个表达式，用逗号分开，所以最终的值应该是最后一个表达式的值，也就是d+3=8，所以a=8。8、位逻辑运算符包括：1。&位与符 2。|位或符 3。^位异或符 4。~位取反符　　以操作数12为例。位运算符将数字12视为1100。位运算符将操作数视为位而不是数值。数值　　可以是任意进制的：十进制、八进制或十六进制。位运算符则将操作数转化为二进制，并相应地返回1或0。　　位运算符将数字视为二进制值，并按位进行相应运算，运算完成后再重新转换为数字。例如：　　表达式10&15表示(1010 & 1111)，它将返回表示1010的值10。因为真真得真，或者是11得1，同位全是1结果也是1　　表达式10|15表示(1010 | 1111),它将返回表示1111的值15。假假得假。全零得零。　　表达式10^15表示(1010 ^ 1111), 它将返回表示0101的值5。此时是同性相斥，相同的就为假。　　表达式~10表示(~1010)，它将返回表示0101的值 -11。此号好理解，按位取反。
采纳率：95%
来自团队：
那么此时等价于argtest(3, 3);所以输出结果是i=3，i前加, ++i); 在参数传递的时候，所以等价于argtest(1, 1)。对于你有疑问的argtest(++i，以argtest(i++, i++)为例，在传递参数前进行的是i++运算，因为i++是后加运算，也就是使用i之后，再对i进行自加运算。而++i是先进行自加运算, i++)来说：i=1, i++)和argtest(i++，然后再使用i。对argtest(i。i++称为后加,j=2,j=3 i=2,j=1i=1,j=1i=3。正解是你给的输出结果是错的，而且前加了两次,j=3 。最后要说的是
本回答被提问者采纳
所以这样的问题无意义，怎么做都不算错。学校里最爱出这种题目，要看做编译器的人怎么实现的，在C标准中都是没有做出明确规定的。所以具体输出什么argtest(i, i++);argtest(i++, i++);argtest(++i, ++i);argtest(i++, ++i);这都是未定义行为
本回答被网友采纳
++在前先运算 ++在后先传参
其他1条回答
为您推荐：
其他类似问题
您可能关注的内容
c语言的相关知识
换一换
回答问题，赢新手礼包
个人、企业类
违法有害信息,请在下方选择后提交
色情、暴力
我们会通过消息、邮箱等方式尽快将举报结果通知您。