Question

还是 关于一个C++的小问题

1. const int SiZe=15
int SiZe=15 这两个函数的具体差别！const基本用处及用法、及使用需要注意什么？

2.int yamcosts〔3〕和int yamcosts(double t) 函数上的区别 两者后面括号内的差别有什么?

3.整形和浮点型它们各自几种数据大小排列! (如long等 )

4.sizeof 使用方式及其用处

5.简单类列 C++头文件!(只需要基本注释和名称)

6.strlen 使用方式及其规则
strlen()+1 的解释 以及用法!

Answer 1

1.const int SiZe=15 中的变量SiZe不能改变
int SiZe=15中的SiZe可以改变
const是一个C语言的关键字，它限定一个变量不允许被改变。变量前加const就是所谓的只读变量。注意加了后在程序中变量是不能再被改变值的

2.差别是第一个传到函数内的是个常量3.而第二个传的是形参，即可以传入实参到函数内部

3.int
long int
short int
unsigned int
unsigned short int
unsigned long int
__int16
__int32
__int64
float
char
double
long double

4.sizeof是运算符，可用于任何变量名、类型名或常量值，当用于变量名（不是数组名）或常量时，它不需要用圆括号。
例子：sizeof(int a);就是求整型a的长度

5.#include <assert.h> //设定插入点
#include <ctype.h> //字符处理
#include <errno.h> //定义错误码
#include <float.h> //浮点数处理
#include <fstream.h> //文件输入／输出
#include <iomanip.h> //参数化输入／输出
#include <iostream.h> //数据流输入／输出
#include <limits.h> //定义各种数据类型最值常量
#include <locale.h> //定义本地化函数
#include <math.h> //定义数学函数
#include <stdio.h> //定义输入／输出函数
#include <stdlib.h> //定义杂项函数及内存分配函数
#include <string.h> //字符串处理
#include <strstrea.h> //基于数组的输入／输出
#include <time.h> //定义关于时间的函数
#include <wchar.h> //宽字符处理及输入／输出
#include <wctype.h> //宽字符分类

//////////////////////////////////////////////////////////////////////////

标准 C++ （同上的不再注释）

#include <algorithm> //STL 通用算法
#include <bitset> //STL 位集容器
#include <cctype>
#include <cerrno>
#include <clocale>
#include <cmath>
#include <complex> //复数类
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque> //STL 双端队列容器
#include <exception> //异常处理类
#include <fstream>
#include <functional> //STL 定义运算函数（代替运算符）
#include <limits>
#include <list> //STL 线性列表容器
#include <map> //STL 映射容器
#include <iomanip>
#include <ios> //基本输入／输出支持
#include <iosfwd> //输入／输出系统使用的前置声明
#include <iostream>
#include <istream> //基本输入流
#include <ostream> //基本输出流
#include <queue> //STL 队列容器
#include <set> //STL 集合容器
#include <sstream> //基于字符串的流
#include <stack> //STL 堆栈容器
#include <stdexcept> //标准异常类
#include <streambuf> //底层输入／输出支持
#include <string> //字符串类
#include <utility> //STL 通用模板类
#include <vector> //STL 动态数组容器
#include <cwchar>
#include <cwctype>

using namespace std;

6.strlen是计算字符串长度的函数
strlen 原型：extern int strlen(char *s);
用法：#include <string.h>
功能：计算字符串s的(unsigned int型）长度
说明：返回s的长度，不包括结束符NULL。
举例：
// strlen.c
#include <syslib.h>
#include <string.h>
main()
{
char *s="Golden Global View";
clrscr();
printf("%s has %d chars",s,strlen(s));
getchar();
return 0;
}

strlen（）+1是指在取得长度数值上再加1

Answer 2

我也是网上搜集的，对你的问题逐个进行解答
一。
1、什么是const?
常类型是指使用类型修饰符const说明的类型，常类型的变量或对象的值是不能被更新的。
为什么引入const？
const 推出的初始目的，正是为了取代预编译指令，消除它的缺点，同时继承它的优点。
3、cons有什么主要的作用？
（1）可以定义const常量，具有不可变性。 例如：
const int Max=100; int Array[Max];
（2）便于进行类型检查，使编译器对处理内容有更多了解，消除了一些隐患。例如： void f(const int i) { .........} 编译器就会知道i是一个常量，不允许修改； （3）可以避免意义模糊的数字出现，同样可以很方便地进行参数的调整和修改。 同宏定义一样，可以做到不变则已，一变都变！如（1）中，如果想修改Max的内容，只需要：const int Max=you want;即可！
（4）可以保护被修饰的东西，防止意外的修改，增强程序的健壮性。 还是上面的例子，如果在函数体内修改了i，编译器就会报错； 例如：
void f(const int i) { i=10;//error! }
（5） 为函数重载提供了一个参考。
class A { ......
void f(int i) {......} //一个函数
void f(int i) const {......} //上一个函数的重载 ......
};
（6） 可以节省空间，避免不必要的内存分配。 例如：
#define PI 3.14159 //常量宏
const doulbe Pi=3.14159; //此时并未将Pi放入ROM中 ......
double i=Pi; //此时为Pi分配内存，以后不再分配！
double I=PI; //编译期间进行宏替换，分配内存
double j=Pi; //没有内存分配
double J=PI; //再进行宏替换，又一次分配内存！
const定义常量从汇编的角度来看，只是给出了对应的内存地址，而不是象#define一样给出的是立即数，所以，const定义的常量在程序运行过程中只有一份拷贝，而#define定义的常量在内存中有若干个拷贝。
（7） 提高了效率。 编译器通常不为普通const常量分配存储空间，而是将它们保存在符号表中，这使得它成为一个编译期间的常量，没有了存储与读内存的操作，使得它的效率也很高。

4、如何使用const？
（1）修饰一般常量 一般常量是指简单类型的常量。这种常量在定义时，修饰符const可以用在类型说明符前，也可以用在类型说明符后。 例如：
int const x=2; 或 const int x=2;
（2）修饰常数组 定义或说明一个常数组可采用如下格式：
int const a[5]={1, 2, 3, 4, 5};
const int a[5]={1, 2, 3, 4, 5};
（3）修饰常对象 常对象是指对象常量，定义格式如下：
class A; const A a;
A const a; 定义常对象时，同样要进行初始化，并且该对象不能再被更新，修饰符const可以放在类名后面，也可以放在类名前面。
（4）修饰常指针
const int *A; //const修饰指向的对象，A可变，A指向的对象不可变
int const *A; //const修饰指向的对象，A可变，A指向的对象不可变
int *const A; //const修饰指针A， A不可变，A指向的对象可变
const int *const A;//指针A和A指向的对象都不可变
（5）修饰常引用 使用const修饰符也可以说明引用，被说明的引用为常引用，该引用所引用的对象不能被更新。其定义格式如下：
const double & v;
（6）修饰函数的常参数 const修饰符也可以修饰函数的传递参数，格式如下：
void Fun(const int Var); 告诉编译器Var在函数体中的无法改变，从而防止了使用者的一些无意的或错误的修改。
（7）修饰函数的返回值： const修饰符也可以修饰函数的返回值，是返回值不可被改变，格式如下：
const int Fun1(); const MyClass Fun2();
（8）修饰类的成员函数： const修饰符也可以修饰类的成员函数，格式如下：
class ClassName {
public:
int Fun() const; .....
}； 这样，在调用函数Fun时就不能修改类里面的数据
（9）在另一连接文件中引用const常量
extern const int i;//正确的引用
extern const int j=10;//错误！常量不可以被再次赋值 另外，还要注意，常量必须初始化！ 例如： const int i=5;
具体请参看http://zhidao.baidu.com/question/91670015.html?si=1

二。区别是第一个3是实参，他在作为函数调用的时候传递给形参，第二个是函数的定义，括号内的区别就是形参和实参的区别，其中t可以省略，如果传递的实参是3，那么将3转化为浮点形式的3.00000

三，这个问题看不开懂，你是问强制转化的方向吗？那么是浮点型>整型>字符型
就是低精度的向高精度的转化

四，sizeof用与测试变量类型长度（即所占字节数），格式sizeof（ 变量类型 ）
例如：测试整形int所占字节数 ，sizeof（ int ），显示结果：4

五，传统 C/C++

#include <assert.h> //设定插入点
#include <ctype.h> //字符处理
#include <errno.h> //定义错误码
#include <float.h> //浮点数处理
#include <fstream.h> //文件输入／输出
#include <iomanip.h> //参数化输入／输出
#include <iostream.h> //数据流输入／输出
#include <limits.h> //定义各种数据类型最值常量
#include <locale.h> //定义本地化函数
#include <math.h> //定义数学函数
#include <stdio.h> //定义输入／输出函数
#include <stdlib.h> //定义杂项函数及内存分配函数
#include <string.h> //字符串处理
#include <strstrea.h> //基于数组的输入／输出
#include <time.h> //定义关于时间的函数
#include <wchar.h> //宽字符处理及输入／输出
#include <wctype.h> //宽字符分类

//////////////////////////////////////////////////////////////////////////

标准 C++ （同上的不再注释）

#include <algorithm> //STL 通用算法
#include <bitset> //STL 位集容器
#include <cctype>
#include <cerrno>
#include <clocale>
#include <cmath>
#include <complex> //复数类
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque> //STL 双端队列容器
#include <exception> //异常处理类
#include <fstream>
#include <functional> //STL 定义运算函数（代替运算符）
#include <limits>
#include <list> //STL 线性列表容器
#include <map> //STL 映射容器
#include <iomanip>
#include <ios> //基本输入／输出支持
#include <iosfwd> //输入／输出系统使用的前置声明
#include <iostream>
#include <istream> //基本输入流
#include <ostream> //基本输出流
#include <queue> //STL 队列容器
#include <set> //STL 集合容器
#include <sstream> //基于字符串的流
#include <stack> //STL 堆栈容器
#include <stdexcept> //标准异常类
#include <streambuf> //底层输入／输出支持
#include <string> //字符串类
#include <utility> //STL 通用模板类
#include <vector> //STL 动态数组容器
#include <cwchar>
#include <cwctype>

using namespace std;

//////////////////////////////////////////////////////////////////////////

C99 增加

#include <complex.h> //复数处理
#include <fenv.h> //浮点环境
#include <inttypes.h> //整数格式转换
#include <stdbool.h> //布尔环境
#include <stdint.h> //整型环境
#include <tgmath.h> //通用类型数学宏

六，strlen 是个函数,是求字符串的长度,不包括结尾的'\0'
格式 strlen(字符串指针); 比如r=strlen("student"),那么r的值为7
strlen()+1就是自加1而已

好了，如果觉得可以就给分吧

Answer 3

1、const int SiZe=15 ，SiZe是整型常量，存储到常量区，在下面操作中其值是不改变的，这是要注意的；在程序中，如果某个量一直不改变的话，就要把它声明为常量的，例如：PI=3.1415926...
而int SiZe=15 ，是定义了一个自由变量SiZe，存储到栈区，其值可以改变的

2、int yamcosts[3]是定义了一个可存放3个整型数值的数组，3是数组元素个数；而int yamcosts(double t)是声明一个返回值是整型的函数，其中double t，t是形式参数

3、整型数和浮点数可存放的最大数值排序是：int型占4字节，而double（浮点型）占8字节

4、用于计算变量或数组占用的字节数，后面是变量名，计算结果就是该变量在内存里占的字节数，当后面是数组名时，结果是该数组存储的所有元素占的字节总数，并用括号，例如：sizeof（var），var是数组名

5、头文件是vc项目里的一种文件，一般用于存放类、函数等的定义，文件后缀是.h，在源文件中用#include包含到源文件中

6、计算字符型数组元素个数，例如strlen（数组名）;strlen()+1 就是数组元素个数再加1

Answer 4

1.const int SiZe=15 ,size的值不可改动。后者可以。
2.如果在同一个函数里面，后者的t=3.000000.double表示括号内的数值为双精度浮点数。
3.short int=16位，long int=float=32位，double=63位，char=8位。
4.color[n] = (char *)malloc(sizeof(char)*(strlen(str)+1));这个句子的意思是把函数strlen所需要的存储长度分配到color函数中。（这个句子是我前几天的程序里复制过来的。）sizeof作用就是说明存储长度的来源。
5.c++头文件在编程环境里面都有，在一个名为“include”的文件夹下。
6.定义格式：int strlen（char *s）。作用 是计算字符串s的长度。

Answer 5

1 const int SIZE = 15 有两方面作用
表示SIZE这个变量不改变 SIZE = 16; 这个会出现错误
另外const变量在多处被引用，可以在一处修改
比如：
const int SIZE = 15;
int size_ = SIZE + SIZE
....
....
int _size = SIZE * SIZE
....
...
int size = SIZE + 10;
如果你发现SIZE不应该是15，应该是16，你只需要修改
const int SIZE = 16即可，不需要管下面其它的代码