The result of tag: (3 results)

C++零基础——auto与decltype区别

by LauCyun Jun 18,2015 00:26:22 4,470 views

1、auto

关键字 auto 是修饰未知变量的类型,编译器会通过此变量的初始化自动推导变量的类型。如果初始值是常量、变量,如:

auto a = 0; //编译器会通过“0”值,推导出变量a是int

double b = 10.123;
auto c = b; //编译器会通过c指向的对象b,推导出c是double

如果初始值是引用,如:

int a = 10;
int &ra(a);
auto b = ra;  //编译器通过ra指向的对象a,推导出b的类型是int

结论:auto 是无法区分常量、变量,变量、引用。

2、decltype

关键字 decltype 能够推导表达式或者函数的返回类型,但不对表达式求值。
如果变量是函数返回类型,那么 decltype 修饰的变量也是函数返回类型。如:

decltype(fun()) sum = x;  //编译器自动推导出sum的类型是fun返回值类型

如果变量是引用,那么 decltype 修饰的变量也是引用。如:

int i = 10;
int & ri(i);
decltype(i)  a = 10;  //a的类型是int
decltype(10) b = i;   //b的类型是int
decltype(ri) c = ri;  //c的类型是int &
decltype(ri) d;       //error C2530: “d”: 必须初始化引用

当表达式不是变量,而是可作为左值的对象时,那么 decltype 返回的时指向该对象类型的应用。

int i = 10;
int *p = &i;  
decltype(*p) pri = i; //pri的类型是int &
decltype(p) pi = &i;  //pri的类型是int *

结论:decltype 可以获取常量属性,获取引用属性 。


...

Tags Read More


C++零基础——简单的C++程序实例

by LauCyun May 07,2013 12:24:33 5,197 views

分析C与C++结构体的区别。


1、C++结构体可以为空,而C不可以为空。

C:
struct MyStruct
{
	//error C2016: C 要求一个结构或联合至少有一个成员   
};
 
C++:
struct MyStruct
{
	
};

2、C++结构体可以初始值,而C不能初始值。

C:
struct MyStruct
{
	int num = 10;//error C2143: 语法错误 : 缺少“;”(在“=”的前面)
};

C++:
struct MyStruct
{
	int num = 10;//C++结构体可以初始化值
};

3、定义变量时,C++结构体无需关键字struct,而C需要关键字struct。

C:
struct MyStruct
{
	int num;
};
int main()
{
	//MyStruct my1; //error C2065: “MyStruct”: 未声明的标识符
	struct MyStruct my1; //定义一个my1变量
	return 0;
}


C++:
struct MyStruct
{
	int num = 10;
};
int main()
{
	MyStruct my1;
 //定义一个my1变量
	return 0;
}

4、C++结构体成员可以是函数,而C不可以。

C:
struct MyStruct
{
	int num;
	void fun()  //error C2032: “fun”: 函数不能是 struct“MyStruct” 的成员 
	{
	}
};

C++:
struct MyStruct
{
	int num;
	void fun() //C++结构体成员可以有函数
	{
	}
};

5、C++结构体成员可以是函数指针,也可是lambda函数块,但是代码体积不计入大小。

#include<iostream>
#include<functional>
using namespace std;

struct MyStructX1
{
	void(*p)() = []() {};
};
struct MyStructX2
{
	function<void(void)>  fun1 = []() {};
};
struct MyStructX3
{
	void(*p)() = []() {};
	function<void(void)>  fun1 = []() {};
	function<void(int)>  fun2 = [](int a) {};
};
struct MyStructX4
{
	void(*p)() = []() {};
	function<void(void)>  fun1 = []() {};
	function<void(int)>  fun2 = [](int a) {};
	function<void(double)>  fun3 = [](int a) {};
	function<void(char *)>  fun4 = [](char*str) {cout << "hello " << str; };
};

int main()
{
	//一个函数指针x86中占4个字节,x64占8个字节
	cout << sizeof(MyStructX1) << endl; //4,8
	//在vs2013中一个fun函数包装器x86中占24个字节,x64中占32个字节
	//在vs2015中一个fun函数包装器x86中占40个字节,x64中占64个字节
	cout << sizeof(MyStructX2) << endl;	//24,32
	cout << sizeof(MyStructX3) << endl; //56,72
	cout << sizeof(MyStructX4) << endl; //104,136
	return 0;
}
在vs2013中一个fun函数包装器x86中占24个字节,x64中占32个字节。
在vs2015中一个fun函数包装器x86中占40个字节,x64中占64个字节。


6、C++结构体默认公有,可以设置私有。

struct MyStruct
{
private:  //默认public
	int num = 3;
	function<void(void)>  fun = []() {};
	void go()
	{
	}
};

7、C++结构体中成员是 public 时的初始化方法。

#include<iostream>
using namespace std;

struct point
{
	int x;
	int y;
};

int main()
{
	point p1{ 101, 102 }; //初始化结构体
	point *p2 = new point{ 201, 202 }; //初始化结构体指针
	point p3[2] = { { 310, 320 }, { 330, 340 } }; //初始化结构体数组
	point *p4 = new point[2]{{ 410, 420 }, { 430, 440 } }; //初始化结构体指针数组
	return 0;
}

8、C++结构体中成员是 private 时的初始化方法。

#include<iostream>
using namespace std;

struct sizeit
{
private:
	int x;
	int y;
public:
	//构造函数
	sizeit(int a, int b) :x(a), y(b)//用a初始化x,b初始化y
	{
	}
	void show()
	{
		cout << "x=" << x << ",y=" << y << endl;
	}
};

int main()
{
	sizeit s1(1, 2);
	s1.show();  //x=1,y=2
	sizeit *ps1 = new sizeit(3, 4);//指针
	ps1->show(); //x=3,y=4
	sizeit s2[3]{ sizeit(13, 14), sizeit(23, 24), sizeit(33, 34) };//数组
	s2[0].show(); //x=13,y=14
	sizeit *ps2 = new sizeit[3]{ sizeit(13, 14), sizeit(23, 24), sizeit(33, 34) };//堆上数组
	(ps2 + 1)->show(); //x=23,y=24
	
	sizeit s3(888,999);
	sizeit s4 = s3; //赋值拷贝,无论私有或者公有
	//cout << s4.x << s4.y << endl;//error C2248: “MyStruct::x”: 无法访问 private 成员(在“sizeit”类中声明)
	s4.show();

	return 0;
}

9、C++结构体中,结构体的声明的前提是只能创建指针、引用,用于拓展结构体作用范围。

#include<iostream>
using namespace std;

struct MyStruct; //结构体的声明
MyStruct *p;     //创建结构体指针
MyStruct my1;    //error C2079: “my1”使用未定义的 struct“MyStruct”
void show(MyStruct & my) //创建结构体引用
{
}
struct MyStruct
{
	int num = 10;
	double db;
};

10、C++结构体内部,可以创建引用或者指针

struct MyStruct
{
	int num = 10;
	double db;
	//struct MyStruct s1; //error C2460: “MyStruct::s1”: 使用正在定义的“MyStruct”
	struct MyStruct *p;   //创建结构体指针
	struct MyStruct &rp;  //创建结构体引用
};

11、C++匿名结构体成员不可以初始化。

struct
{
	double db;
	//int num =10; //error C2905: “<unnamed-tag>::num”: 非类范围内的匿名联合的成员不允许类内初始值设定项
};

12、C++结构体,可以继承,也可以多态。

(1)结构体继承:

#include<iostream>
using namespace std;
struct parent
{
	virtual void show()
	{
		cout << "parent" << endl;
	}
};
struct children : public parent
{
};

int main()
{
	//结构体可以继承
	children x;
	x.show(); //parent
	return 0;
}

(2)结构体多态:

#include<iostream>
using namespace std;
struct parent
{
	virtual void show()
	{
		cout << "parent" << endl;
	}
};
struct children : public parent
{
	void show()
	{
		cout << "children" << endl;
	}
};

int main()
{
	//多态
	parent *p = new parent;
	p->show();  //parent
	p = new children;
	p->show();  //children
	return 0;
}

 

...

Tags Read More


C++零基础——C++变量和常量

by LauCyun May 06,2013 19:51:19 4,608 views

变量和常量是用来在程序中表示数据的。常量是指取值在程序的执行过程中始终保持不变的量,又分为文字常量(Literal constant)和常变量(也称“符号常量”)。

1、变量

变量:在程序中是指可以改变值的量。

变量名:用于标识变量的标识符。而且变量必须用标识符进行标识。
变量的类型:变量有类型之分,如整形变量、字符变量等。
变量的说明:任何变量都必须先说明后使用。
目的:一是便于编译程序为变量分配空间,二是便于编译时进行语法检查。
格式:在C++中,变量说明的一般格式为:

[存储类型]<数据类型> <变量名1>[,<变量名2>,…,<变量名n>];
例:
int i, j, k;          //说明3个整型变量i,j,k
float x,y,z;      //说明3个实型变量x,y,z
char c1, c2;    //说明2个字符型变量c1,c2
double dx;      //说明1个双精度型变量dx
变量的使用:变量使用的第一步,是给变量赋初始值,称为“初始化”。
有两种方法:
    a. 变量说明时直接赋初值:
 int a=3, b=4, c=5;   
 float x=3.0
    b. 用赋值语句赋初值: 
float x, e;    
x=3.5;   
e=2.71828;

2、文字常量

文字常量指程序中直接给出的量。文字常量存储在程序区,而不是数据区;对它的访问不是通过数据地址进行的。

根据取值和表示方法的不同,可分为整型常量、实型常量、字符型常量和字符串常量。

  • 整型常量:即整数,可以有多种表示方法。

     a. 十进制表示法:是平时的习惯写法,例如:15 -24;

    b. 八进制表示法:以0打头,由数字0~7组成。例如:   

012      //八进制数12,即十进制数10   
-6555    //八进制数-655,即十进制数-429

    c. 十六进制表示法:以0X(大小写均可)打头,由数字0~9和字母A~F(大小写均可)组成,用来表示一个十六进制数。例如: 

0x32A       //十六进制数32A,即十进制数810   
-0x2fe0   //十六进制数-2fe0,即十进制数-12256

    d. 其他表示法:还可以表示以 L或l结尾的长整数和以U或u结尾的无符号整数。以UL或LU(大小写均可)结尾则可表示无符号长整型常数。例如:    

-84L        //十进制长整数-84    
026U       //八进制表示的无符号数26    
0X32LU     //十六进制表示的无符号长整数32
  • 实型常量:包含小数点和10的幂的数,有两种表示方法:

    a. 一般形式:与平时书写形式相同,由数字0 ~9和小数点组成。例如:    

        0.23、 -125.76、 0.0、 .46、 -35.
    b. 指数形式:即科学表示法,表示为尾数乘以10的次方形式,由尾数、E或e和阶数组成。要求在E或e前面的尾数部分必须有数字,后面的指数部分必须为整数。

        判断下列实型常量表示是否合法:(答案:红色的不合法)

        123E12 、 E4 、 1.43E3.5 、 -.34e-2 ;

  • 字符型常量:用单引号引起来的单个字符。

    a. 保存形式:在内存中保存的是字符的ASCII码值。

    b. 直接表示形式:对于可显示字符,通常用单引号直接引起来表示。

    例如:  

     'a'   //字符a            '4'   //字符4               '@'   //字符@               ' '   //空格字符

     c. 转义序列表示法:对于不可显示的或无法从键盘输入的字符,如回车符、换行符、制表符、响铃、退格等;另外,还有几个具有特殊含义的字符,如反斜杠、单引号和双引号等,C++提供了一种称为“转义序列”的表示方法。例如:

      '\a'   //响铃             '\n'   //换行符                 '\\'   //字符\   
     下表给出C++中预定义的转义序列字符及其含义。

字符表示
ASCII码值
名 称
功 能 或 用 途
\a0x07
响铃
用于输出
\b0x08
退格(Backspace键)
退回一个字符
\f0x0c
换页
用于输出
\n0x0a
换行符
用于输出
\r0x0d
回车符
用于输出
\t0x09
水平制表符(Tab键)
用于输出
\v0x0b
纵向制表符
用于制表
\00x00
空字符
用于字符串结束标志等
\\0x5c
反斜杠字符
用于需要反斜杠字符的地方
\′0x27
单引号字符
用于需要单引号的地方
\″0x22
双引号字符
用于需要双引号的地方
\nnn八进制表示 用八进制ASCII码表示字符
\xnn十六进制表示 用十六进制ASCII码表示字符

     说明:
       a). 上表中最后两行是所有字符的通用表示方法,即用反斜杠加ASCII码表示。
       b). 对于可显示字符,有三种表示方法。以字母a为例: ′a′、′\141′和′\x61′
       c.) 显然,对于可见字符,第一种是最简单直观的表示方法。

  • 字符串常量:由一对双引号″″引起来的若干个字符组成。例如:″I am a Chinese.″、 ″123″、 ″a″、 ″ ″

     字符串常量与字符型常量的区别如下:

       a. 字符串常量″a″占两个字节,存放'a'和'\0',如图左半部分,值为0x6100;
       b. 字符型常量'a' 占一个字节,存放'a',如图右半部分,值为0x61。

3、常变量

用常量说明符const给文字常量命名所得的标识符就称为“标识符常量”。因为标识符常量的说明和引用形式很像变量,所以也称“常变量”。例如:
const float PI=3.14159;    //定义了常变量PI
const int Number_of_Student=100; //定义了常变量Number_of_Student

在使用常变量时应注意以下几点:
    a. 常变量必须也只能在说明时进行初始化。
    b. 常变量初始化之后,不允许再被赋值。
    c. 常变量必须先说明后使用。

...

Tags Read More