C++语法1

1.程序的运行,不再是一个进程硬要全面主宰一切那样完成任务的形式,而是面对环境中正在”生活中”的对象,不时地请求其服务,以达到完成计算的目的.

那些生活中的对象也不是为了某个进程而活着,而是各司其职充当系统的一个部件而已..

在程序员眼里,所谓程序,是满世界的对象,它们在计算机系统的舞台上,悠闲地尽着自己的本分,程序的形式变成: 程序=(对象,对象,对象,……)

要解决的问题实体是对象,分解以后又是一系列具有层次结构的对象,运行中也是对象的世界,总之,世界是对象的,我们面向对象而分析,设计,编程.这就是面向对象程序设计的着眼点.

2.“/”运算,负负得正.”%”运算,余数结果取决于被除数.-11%-5=-1

3.枚举的整数区间为包含头尾整数取值的最小2的幂次值。

4.string是一种自定义类型，可以方便地执行C-串所不能直接执行的一切操作。

5.向量（Vectors）

Vector是向量类型，它是一种对象实体。可以容纳许多其他类型的相同实体，如若干个整数，所以称其为容器。Vector是C++STL的重要一员。

Vector可以有四种定义方式

①vector a(10); 定义了10个整数元素的向量，没初始化值，其值不确定

②vector b(10,1); 定义了10个整数元素的向量，切将每个元素初始值为1

③vector c(b);用另外一个向量b来创建c向量

④vector d(b.begin(),b.begin()+3);定义一个值依次为b向量中第0到第2个（共3个）元素的向量

b.begin()表示向量起始元素位置，b.end()向量最后一个元素之外的位置。

向量元素位置也属于一种类型，成为遍历器。遍历器不单表示元素位置，还可以在容器中游动，每种容器都有对应的遍历器。。向量中遍历器类型为vector::iterator。

vector<int>vec(15,3);
for(vector<int>::iterator it=vec.begin(); it!=vec.end(); ++it)
   cout<<*it<<" ";

a.size()是向量中元素的个数，a.begin()表示向量的第一个元素，这种操作方式是一个对象捆绑一个函数调用。
a.assign(b.begin(),b.begin()+3);// b向量的0，1，2元素构成向量付给a
a.assign(4,2);//使a向量只含0～3元素，赋值2
int x = a.back(); //将a的最后一个向量元素赋值给整数x
a.clear()；//a向量中元素清空
if(a.empty()) cout<<”empty”;
a.pop_back();//删除a向量的最后一个元素
a.push_back(5);//在a向量最后插入一个元素，值为5
a.resize(10);//将向量元素个数调制10个，多则删，少则补，其值未知
a.resize(10,2);// 将向量元素个数调制10个，多则删，少则补，其值为2
if(a==b) cout<<”equal”; //

除此之外，还有元素的插入与删除、保留元素个数、容量观察等操作。

二维向量用法

#include <iostream>
#include <fstream>
#include <sstream>
#include <vector>
using namespace std;
//--------------------------------------------------
typedef vector<vector<int> > Mat;
Mat input();
void mySort(Mat&a);
void print(const Mat&a);
int main(int argc, char* argv[])
{
        Mat a = input();
        mySort(a);
        print(a);
        while(1);
        return 0;
}
//-----------------------------------------------
Mat input(){
  ifstream in("abc.txt");
  Mat a;
  for (string s; getline(in,s);){
    vector<int> b;
    istringstream sin(s);
    for (int ia; sin>>ia;)
      b.push_back(ia);
      a.push_back(b);
  }
  return a;
}
//------------------------------------------
void mySort(Mat& a)
{
  for (int pass=1; pass<a.size();++pass)
  for (int i=0; i<a.size()-pass;++i)
    if (a[i+1].size()<a[i].size())
      a[i].swap(a[i+1]);
}
//-----------------------------------------------
void print(const Mat& a)
{
  for (int i=0; i<a.size();++i) {
    for(int j=0; j<a[i].size();++j)
     cout<<a[i][j]<<" ";
     cout<<endl;
  }
}
//---------------------------------------------------------------------------

6.指针常量

Const修饰的知识限定指针的操作，但不能限定空间上的实体的可改变行。

Int a=78,c=60;
Const int*ip=&a;
Const int *const icp = &c;
A=50;c=30;//合法

7.引用reference

引用定义时必须要初始化，这是与指针不同的地方，给引用初始化的总是一个内存实体，而不是地址，他可以是变量或常量，其严格要求类型匹配。

#include <iostream>
using namespace std;
int main(int argc, char* argv[])
{
        int int1 = 5;
        int& rInt = int1;
        cout<<"&int1:"<<&int1<<"  int1:"<<int1<<endl;
        cout<<"&rInt:"<<&rInt<<"  rInt:"<<rInt<<endl;
        int int2=8;
        rInt = int2;
        cout<<"&rInt:"<<&rInt<<"  rInt:"<<rInt<<endl;
        cout<<"&int1:"<<&int1<<"  int1:"<<int1<<endl;
        while(1);
        return 0;
}
输出结果
&int1:1245064  int1:5
&rInt:1245064  rInt:5
&rInt:1245064  rInt:8
&int1:1245064  int1:8

rInt关联int1后，其值发生变化，但其地址永远不变。

与指针比较，引用隐去了地址操作，引用封锁了这种地址的可修改性，是的间访相对安全。

高级编程多用引用，低级编程多用指针。

8.选择一个数据类型，一定要考虑该类型数据的表示范围。算法总是描述一般的方法，而编程总是考虑语言描述的局限性。

9.显示转换

转换是逐个进行的，“1.2+3/5”，值是3.2，不是3.7

转换不能改变实体，它只是将实体的内容读出，求得转换，返回其结果。

double d=3.2;
int a = static_cast<int>(d);     //等价于int a = d;
a = reinterpret_cast<int>(d);    //错，不能转换
int *ip = reinterpret_cast<int *>(&d);      //
ip = static_cast<int *>(&d);                // 不能转换

10.表达式副作用

增量操作会引起副作用，比如

int a=3,b=5;

int c = ++b*(a+b);

int d = (a+b)*(++b);

c与d是不能保证相等的，是由于编译器的求职顺序不确定所引起。

表达式有副作用的根本原因是，充当操作数的模块可能会影响同一个表达式的另一个操作数模块的计算值。