A type has value semantics if the object's observable state is functionally distinct from all other objects of that type. This means that if you copy an object, you have a new object, and modifications of the new object will not be in any way visible from the old object.
Most basic C++ types have value semantics:
int i = 5; int j = i; //Copied j += 20; std::cout << i; //Prints 5; i is unaffected by changes to j.
Most standard-library defined types have value semantics too:
std::vector<int> v1(5, 12); //array of 5 values, 12 in each. std::vector<int> v2 = v1; //Copies the vector. v2 = 6; v2 = 9; std::cout << v1 << " " << v1; //Writes "12 12", since v1 is unchanged.
A type is said to have reference semantics if an instance of that type can share its observable state with another object (external to it), such that manipulating one object will cause the state to change within another object.
C++ pointers have value semantics with regard to which object they point to, but they have reference semantics with regard to the state of the object they point to:
int *pi = new int(4); int *pi2 = pi; pi = new int(16); assert(pi2 != pi); //Will always pass. int *pj = pi; *pj += 5; std::cout << *pi; //Writes 9, since `pi` and `pj` reference the same object.
C++ references have reference semantics as well.